Merge pull request #425 from yuyichao/0.7

Fix most of 0.7 depwarns

Author: yuyichao

REQUIRE

@@ -1,4 +1,4 @@
 julia 0.5
-Compat 0.27.0
+Compat 0.32.0
 Conda 0.2
 MacroTools 0.3

deps/build.jl

@@ -10,8 +10,6 @@ import Conda
 
 immutable UseCondaPython <: Exception end
 
-try # make sure deps.jl file is removed on error
-
 #########################################################################
 
 # Fix the environment for running `python`, and setts IO encoding to UTF-8.
@@ -36,7 +34,7 @@ function pythonenv(cmd::Cmd)
     setenv(cmd, env)
 end
 
-pyvar(python::AbstractString, mod::AbstractString, var::AbstractString) = chomp(readstring(pythonenv(`$python -c "import $mod; print($mod.$var)"`)))
+pyvar(python::AbstractString, mod::AbstractString, var::AbstractString) = chomp(read(pythonenv(`$python -c "import $mod; print($mod.$var)"`), String))
 
 pyconfigvar(python::AbstractString, var::AbstractString) = pyvar(python, "distutils.sysconfig", "get_config_var('$var')")
 pyconfigvar(python, var, default) = let v = pyconfigvar(python, var)
@@ -113,7 +111,7 @@ function find_libpython(python::AbstractString)
             print(s, "\n\n")
         end
         println(STDERR, "---------------------------------- get_config_vars ---------------------------------------")
-        print(STDERR, readstring(`python -c "import distutils.sysconfig; print(distutils.sysconfig.get_config_vars())"`))
+        print(STDERR, read(`python -c "import distutils.sysconfig; print(distutils.sysconfig.get_config_vars())"`, String))
         println(STDERR, "--------------------------------- directory contents -------------------------------------")
         for libpath in libpaths
             if isdir(libpath)
@@ -142,76 +140,6 @@ include("depsutils.jl")
 
 #########################################################################
 
-const python = try
-    let py = get(ENV, "PYTHON", isfile("PYTHON") ? readchomp("PYTHON") :
-                 Compat.Sys.islinux() || Sys.ARCH ∉ (:i686, :x86_64) ? "python" : ""),
-        vers = isempty(py) ? v"0.0" : convert(VersionNumber, pyconfigvar(py,"VERSION","0.0"))
-        if vers < v"2.7"
-            if isempty(py)
-                throw(UseCondaPython())
-            else
-                error("Python version $vers < 2.7 is not supported")
-            end
-        end
-
-        # check word size of Python via sys.maxsize, since a common error
-        # on Windows is to link a 64-bit Julia to a 32-bit Python.
-        pywordsize = parse(UInt64, pysys(py, "maxsize")) > (UInt64(1)<<32) ? 64 : 32
-        if pywordsize != Sys.WORD_SIZE
-            error("$py is $(pywordsize)-bit, but Julia is $(Sys.WORD_SIZE)-bit")
-        end
-
-        py
-    end
-catch e1
-    if Sys.ARCH in (:i686, :x86_64)
-        if isa(e1, UseCondaPython)
-            info("Using the Python distribution in the Conda package by default.\n",
-                 "To use a different Python version, set ENV[\"PYTHON\"]=\"pythoncommand\" and re-run Pkg.build(\"PyCall\").")
-        else
-            info( "No system-wide Python was found; got the following error:\n",
-                  "$e1\nusing the Python distribution in the Conda package")
-        end
-        abspath(Conda.PYTHONDIR, "python" * (Compat.Sys.iswindows() ? ".exe" : ""))
-    else
-        error("No system-wide Python was found; got the following error:\n",
-              "$e1")
-    end
-end
-
-use_conda = dirname(python) == abspath(Conda.PYTHONDIR)
-if use_conda
-    Conda.add("numpy")
-end
-
-const (libpython, libpy_name) = find_libpython(python)
-const programname = pysys(python, "executable")
-
-# Get PYTHONHOME, either from the environment or from Python
-# itself (if it is not in the environment or if we are using Conda)
-PYTHONHOME = if !haskey(ENV, "PYTHONHOME") || use_conda
-    # PYTHONHOME tells python where to look for both pure python
-    # and binary modules.  When it is set, it replaces both
-    # `prefix` and `exec_prefix` and we thus need to set it to
-    # both in case they differ. This is also what the
-    # documentation recommends.  However, they are documented
-    # to always be the same on Windows, where it causes
-    # problems if we try to include both.
-    exec_prefix = pysys(python, "exec_prefix")
-    Compat.Sys.iswindows() ? exec_prefix : pysys(python, "prefix") * ":" * exec_prefix
-else
-    ENV["PYTHONHOME"]
-end
-
-# cache the Python version as a Julia VersionNumber
-const pyversion = VersionNumber(pyvar(python, "platform", "python_version()"))
-
-info("PyCall is using $python (Python $pyversion) at $programname, libpython = $libpy_name")
-
-if pyversion < v"2.7"
-    error("Python 2.7 or later is required for PyCall")
-end
-
 # A couple of key strings need to be stored as constants so that
 # they persist throughout the life of the program.  In Python 3,
 # they need to be wchar_t* data.
@@ -221,15 +149,86 @@ wstringconst(s) = string("Base.cconvert(Cwstring, \"", escape_string(s), "\")")
 # to prevent unnecessary recompilation and to minimize
 # problems in the unlikely event of read-only directories.
 function writeifchanged(filename, str)
-    if !isfile(filename) || readstring(filename) != str
+    if !isfile(filename) || read(filename, String) != str
         info(abspath(filename), " has been updated")
         write(filename, str)
     else
         info(abspath(filename), " has not changed")
     end
 end
 
-writeifchanged("deps.jl", """
+try # make sure deps.jl file is removed on error
+    python = try
+        let py = get(ENV, "PYTHON", isfile("PYTHON") ? readchomp("PYTHON") :
+                     Compat.Sys.islinux() || Sys.ARCH ∉ (:i686, :x86_64) ? "python" : ""),
+            vers = isempty(py) ? v"0.0" : convert(VersionNumber, pyconfigvar(py,"VERSION","0.0"))
+            if vers < v"2.7"
+                if isempty(py)
+                    throw(UseCondaPython())
+                else
+                    error("Python version $vers < 2.7 is not supported")
+                end
+            end
+
+            # check word size of Python via sys.maxsize, since a common error
+            # on Windows is to link a 64-bit Julia to a 32-bit Python.
+            pywordsize = parse(UInt64, pysys(py, "maxsize")) > (UInt64(1)<<32) ? 64 : 32
+            if pywordsize != Sys.WORD_SIZE
+                error("$py is $(pywordsize)-bit, but Julia is $(Sys.WORD_SIZE)-bit")
+            end
+
+            py
+        end
+    catch e1
+        if Sys.ARCH in (:i686, :x86_64)
+            if isa(e1, UseCondaPython)
+                info("Using the Python distribution in the Conda package by default.\n",
+                     "To use a different Python version, set ENV[\"PYTHON\"]=\"pythoncommand\" and re-run Pkg.build(\"PyCall\").")
+            else
+                info( "No system-wide Python was found; got the following error:\n",
+                      "$e1\nusing the Python distribution in the Conda package")
+            end
+            abspath(Conda.PYTHONDIR, "python" * (Compat.Sys.iswindows() ? ".exe" : ""))
+        else
+            error("No system-wide Python was found; got the following error:\n",
+                  "$e1")
+        end
+    end
+
+    use_conda = dirname(python) == abspath(Conda.PYTHONDIR)
+    if use_conda
+        Conda.add("numpy")
+    end
+
+    (libpython, libpy_name) = find_libpython(python)
+    programname = pysys(python, "executable")
+
+    # Get PYTHONHOME, either from the environment or from Python
+    # itself (if it is not in the environment or if we are using Conda)
+    PYTHONHOME = if !haskey(ENV, "PYTHONHOME") || use_conda
+        # PYTHONHOME tells python where to look for both pure python
+        # and binary modules.  When it is set, it replaces both
+        # `prefix` and `exec_prefix` and we thus need to set it to
+        # both in case they differ. This is also what the
+        # documentation recommends.  However, they are documented
+        # to always be the same on Windows, where it causes
+        # problems if we try to include both.
+        exec_prefix = pysys(python, "exec_prefix")
+        Compat.Sys.iswindows() ? exec_prefix : pysys(python, "prefix") * ":" * exec_prefix
+    else
+        ENV["PYTHONHOME"]
+    end
+
+    # cache the Python version as a Julia VersionNumber
+    pyversion = VersionNumber(pyvar(python, "platform", "python_version()"))
+
+    info("PyCall is using $python (Python $pyversion) at $programname, libpython = $libpy_name")
+
+    if pyversion < v"2.7"
+        error("Python 2.7 or later is required for PyCall")
+    end
+
+    writeifchanged("deps.jl", """
     const python = "$(escape_string(python))"
     const libpython = "$(escape_string(libpy_name))"
     const pyprogramname = "$(escape_string(programname))"
@@ -242,16 +241,16 @@ writeifchanged("deps.jl", """
     const conda = $use_conda
     """)
 
-# Make subsequent builds (e.g. Pkg.update) use the same Python by default:
-writeifchanged("PYTHON", isfile(programname) ? programname : python)
+    # Make subsequent builds (e.g. Pkg.update) use the same Python by default:
+    writeifchanged("PYTHON", isfile(programname) ? programname : python)
 
-#########################################################################
+    #########################################################################
 
 catch
 
-# remove deps.jl (if it exists) on an error, so that PyCall will
-# not load until it is properly configured.
-isfile("deps.jl") && rm("deps.jl")
-rethrow()
+    # remove deps.jl (if it exists) on an error, so that PyCall will
+    # not load until it is properly configured.
+    isfile("deps.jl") && rm("deps.jl")
+    rethrow()
 
 end

src/PyCall.jl

@@ -432,6 +432,7 @@ end
 pyimport(name::Symbol) = pyimport(string(name))
 
 # convert expressions like :math or :(scipy.special) into module name strings
+modulename(s::QuoteNode) = modulename(s.value)
 modulename(s::Symbol) = string(s)
 function modulename(e::Expr)
     if e.head == :.
@@ -462,8 +463,15 @@ end
 macro pyimport(name, optional_varname...)
     mname = modulename(name)
     Name = pyimport_name(name, optional_varname)
+    quoteName = Expr(:quote, Name)
+    # VERSION 0.7
+    @static if isdefined(Base, Symbol("@isdefined"))
+        isdef_check = :(isdefined($__module__, $quoteName))
+    else
+        isdef_check = :(isdefined($quoteName))
+    end
     quote
-        if !isdefined($(Expr(:quote, Name)))
+        if !$isdef_check
             const $(esc(Name)) = pywrap(pyimport($mname))
         elseif !isa($(esc(Name)), Module)
             error("@pyimport: ", $(Expr(:quote, Name)), " already defined")

src/conversions.jl

@@ -565,13 +565,13 @@ function convert{K,V}(::Type{Dict{K,V}}, o::PyObject)
 end
 
 #########################################################################
-# Range: integer ranges are converted to xrange,
-#         while other ranges (<: AbstractVector) are converted to lists
+# AbstractRange: integer ranges are converted to xrange,
+#                while other ranges (<: AbstractVector) are converted to lists
 
 xrange(start, stop, step) = pycall(pyxrange[], PyObject,
                                    start, stop, step)
 
-function PyObject{T<:Integer}(r::Range{T})
+function PyObject{T<:Integer}(r::AbstractRange{T})
     s = step(r)
     f = first(r)
     l = last(r) + s
@@ -583,7 +583,7 @@ function PyObject{T<:Integer}(r::Range{T})
     end
 end
 
-function convert{T<:Range}(::Type{T}, o::PyObject)
+function convert{T<:AbstractRange}(::Type{T}, o::PyObject)
     v = PyVector(o)
     len = length(v)
     if len == 0
@@ -722,7 +722,7 @@ function pysequence_query(o::PyObject)
         len = @pycheckz ccall((@pysym :PySequence_Size), Int, (PyPtr,), o)
         return typetuple([pytype_query(PyObject(ccall((@pysym :PySequence_GetItem), PyPtr, (PyPtr,Int), o,i-1)), PyAny) for i = 1:len])
     elseif pyisinstance(o, pyxrange[])
-        return Range
+        return AbstractRange
     elseif ispybytearray(o)
         return Vector{UInt8}
     else

src/gc.jl

@@ -28,6 +28,9 @@ end
 
 # "embed" a reference to jo in po, using the weak-reference mechanism
 function pyembed(po::PyObject, jo::Any)
+    # If there's a need to support immutable embedding,
+    # the API needs to be changed to return the pointer.
+    isimmutable(jo) && ArgumentError("pyembed: immutable argument now allowed")
     if weakref_callback_obj.o == C_NULL
         weakref_callback_obj.o = pyincref(pymethod(weakref_callback,
                                                    "weakref_callback",

src/io.jl

@@ -108,7 +108,7 @@ function pyio_initialize()
                               String(read(pyio_jl(self), nb < 0 ? typemax(Int) : nb)) :
                               pybytes(read(pyio_jl(self), nb < 0 ? typemax(Int) : nb)))
             readall(self) =
-                @with_ioraise(self[:istextio] ? readstring(pyio_jl(self)) :
+                @with_ioraise(self[:istextio] ? read(pyio_jl(self), String) :
                                                 pybytes(read(pyio_jl(self))))
             readinto(self, b) = @with_ioraise(pybytes(readbytes!(pyio_jl(self), b)))
             write(self, b) = @with_ioraise(write(pyio_jl(self), b))

src/numpy.jl

@@ -74,7 +74,7 @@ function npyinitialize()
     # Parse __multiarray_api.h to obtain length and meaning of PyArray_API
     try
         hdrfile = open(joinpath(inc, "numpy", "__multiarray_api.h"))
-        hdr = readstring(hdrfile);
+        hdr = read(hdrfile, String)
         close(hdrfile)
     catch e
         error("could not read __multiarray_api.h to parse PyArray_API ", e)

src/pybuffer.jl

@@ -40,7 +40,8 @@ end
 function pydecref(o::PyBuffer)
     # note that PyBuffer_Release sets o.obj to NULL, and
     # is a no-op if o.obj is already NULL
-    ccall(@pysym(:PyBuffer_Release), Void, (Ptr{PyBuffer},), &o)
+    # TODO change to `Ref{PyBuffer}` when 0.6 is dropped.
+    ccall(@pysym(:PyBuffer_Release), Void, (Any,), o)
     o
 end
 
@@ -85,9 +86,10 @@ function Base.stride(b::PyBuffer, d::Integer)
     return Int(unsafe_load(b.buf.strides, d))
 end
 
+# TODO change to `Ref{PyBuffer}` when 0.6 is dropped.
 iscontiguous(b::PyBuffer) =
     1 == ccall((@pysym :PyBuffer_IsContiguous), Cint,
-               (Ptr{PyBuffer}, Cchar), &b, 'A')
+               (Any, Cchar), b, 'A')
 
 #############################################################################
 # pybuffer constant values from Include/object.h
@@ -105,8 +107,9 @@ const PyBUF_INDIRECT       = convert(Cint, 0x0100) | PyBUF_STRIDES
 # construct a PyBuffer from a PyObject, if possible
 function PyBuffer(o::Union{PyObject,PyPtr}, flags=PyBUF_SIMPLE)
     b = PyBuffer()
+    # TODO change to `Ref{PyBuffer}` when 0.6 is dropped.
     @pycheckz ccall((@pysym :PyObject_GetBuffer), Cint,
-                     (PyPtr, Ptr{PyBuffer}, Cint), o, &b, flags)
+                     (PyPtr, Any, Cint), o, b, flags)
     return b
 end
 

src/pyclass.jl

@@ -156,7 +156,7 @@ Multiple dispatch works, too:
 """
 macro pydef(class_expr)
     class_name, _, _ = parse_pydef_toplevel(class_expr)
-    :(const $(esc(class_name)) = @pydef_object($(esc(class_expr))))
+    esc(:(const $class_name = $PyCall.@pydef_object($class_expr)))
 end
 
 """

src/pyinit.jl

@@ -87,14 +87,14 @@ function __init__()
 
     if !already_inited
         # some modules (e.g. IPython) expect sys.argv to be set
-        if pyversion.major < 3
-            argv_s = ""
-            argv = unsafe_convert(Ptr{UInt8}, argv_s)
-            ccall(@pysym(:PySys_SetArgvEx), Void, (Cint,Ptr{Ptr{UInt8}},Cint), 1, &argv, 0)
+        @static if VERSION >= v"0.7.0-DEV.1963"
+            ref0 = Ref{UInt32}(0)
+            Base.@gc_preserve ref0 ccall(@pysym(:PySys_SetArgvEx), Void,
+                                         (Cint, Ref{Ptr{Void}}, Cint),
+                                         1, pointer_from_objref(ref0), 0)
         else
-            argv_s = Cwchar_t[0]
-            argv   = unsafe_convert(Ptr{Cwchar_t}, argv_s)
-            ccall(@pysym(:PySys_SetArgvEx), Void, (Cint, Ptr{Ptr{Cwchar_t}}, Cint), 1, &argv, 0)
+            ccall(@pysym(:PySys_SetArgvEx), Void, (Cint, Ptr{Cwstring}, Cint),
+                  1, [""], 0)
         end
 
         # Some Python code checks sys.ps1 to see if it is running