Julia 0.4 compat: AbstractString

Author: stevengj

REQUIRE

@@ -1,2 +1,2 @@
 julia 0.2-
-Compat 0.1
+Compat 0.2

src/PyCall.jl

@@ -315,7 +315,7 @@ function pyinitialize(libpy::Ptr{Void})
             py_void_p::Function = p::Ptr -> PyObject(ccall(pycobject_new, PyPtr, (Ptr{Void}, Ptr{Void}), p, C_NULL))
         end
         pyversion::VersionNumber = 
-          VersionNumber(convert((Int,Int,Int,String,Int), 
+          VersionNumber(convert((Int,Int,Int,AbstractString,Int), 
                                 pyimport("sys")["version_info"])[1:3]...)
         pyhashlong::Bool = pyversion::VersionNumber < v"3.2"
         pyunicode_literals::Bool = pyversion::VersionNumber >= v"3.0"
@@ -348,16 +348,16 @@ function pyinitialize(libpy::Ptr{Void})
     return
 end
 
-pyconfigvar(python::String, var::String) = chomp(readall(`$python -c "import distutils.sysconfig; print(distutils.sysconfig.get_config_var('$var'))"`))
-pysys(python::String, var::String) = chomp(readall(`$python -c "import sys; print(sys.$var)"`))
+pyconfigvar(python::AbstractString, var::AbstractString) = chomp(readall(`$python -c "import distutils.sysconfig; print(distutils.sysconfig.get_config_var('$var'))"`))
+pysys(python::AbstractString, var::AbstractString) = chomp(readall(`$python -c "import sys; print(sys.$var)"`))
 pyconfigvar(python, var, default) = let v = pyconfigvar(python, var)
     v == "None" ? default : v
 end
 
 const dlext = isdefined(Sys, :dlext) ? Sys.dlext : Sys.shlib_ext
 const dlprefix = @windows? "" : "lib"
 
-function dlopen_libpython(python::String)
+function dlopen_libpython(python::AbstractString)
     # it is ridiculous that it is this hard to find the name of libpython
     v = pyconfigvar(python,"VERSION","")
     libs = [ dlprefix*"python"*v*"."*dlext, dlprefix*"python."*dlext ]
@@ -417,7 +417,7 @@ function dlopen_libpython(python::String)
 end
 
 # Python 3.x uses wchar_t arrays for some string arguments
-function wbytestring(s::String)
+function wbytestring(s::AbstractString)
     if pyversion.major < 3 || sizeof(Cwchar_t) == 1 # ASCII (or UTF8)
         bytestring(s)
     else # UTF16 or UTF32, presumably
@@ -451,7 +451,7 @@ function wbytestring(s::String)
 end
 
 # initialize the Python interpreter (no-op on subsequent calls)
-function pyinitialize(python::String)
+function pyinitialize(python::AbstractString)
     global initialized
     if !initialized::Bool
         libpy = try
@@ -559,7 +559,7 @@ function pystring(o::PyObject)
                 return string(o.o)
             end
         end
-        return convert(String, PyObject(s))
+        return convert(AbstractString, PyObject(s))
     end
 end    
 
@@ -631,7 +631,7 @@ isequal(o1::PyObject, o2::PyObject) = o1 == o2 # Julia 0.2 compatibility
 # with the former returning an raw PyObject and the latter giving the PyAny
 # conversion.
 
-function getindex(o::PyObject, s::String)
+function getindex(o::PyObject, s::AbstractString)
     if (o.o == C_NULL)
         throw(ArgumentError("ref of NULL PyObject"))
     end
@@ -646,7 +646,7 @@ end
 
 getindex(o::PyObject, s::Symbol) = convert(PyAny, getindex(o, string(s)))
 
-function setindex!(o::PyObject, v, s::String)
+function setindex!(o::PyObject, v, s::AbstractString)
     if (o.o == C_NULL)
         throw(ArgumentError("assign of NULL PyObject"))
     end
@@ -660,7 +660,7 @@ end
 
 setindex!(o::PyObject, v, s::Symbol) = setindex!(o, v, string(s))
 
-function haskey(o::PyObject, s::String)
+function haskey(o::PyObject, s::AbstractString)
     if (o.o == C_NULL)
         throw(ArgumentError("haskey of NULL PyObject"))
     end
@@ -706,7 +706,7 @@ end
 
 function pywrap(o::PyObject, mname::Symbol=:__anon__)
     @pyinitialize
-    members = convert(Vector{(String,PyObject)}, 
+    members = convert(Vector{(AbstractString,PyObject)}, 
                       pycall(inspect["getmembers"], PyObject, o))
     filter!(m -> !(m[1] in reserved), members)
     m = Module(mname)
@@ -723,7 +723,7 @@ end
 
 #########################################################################
 
-pyimport(name::String) =
+pyimport(name::AbstractString) =
     PyObject(@pycheckn ccall((@pysym :PyImport_ImportModule), PyPtr,
                              (Ptr{Uint8},), bytestring(name)))
 
@@ -805,7 +805,7 @@ function pycall(o::PyObject, returntype::TypeTuple, args...; kwargs...)
             ret = PyObject(@pycheckni ccall((@pysym :PyObject_Call), PyPtr,
                                           (PyPtr,PyPtr,PyPtr), o, arg, C_NULL))
         else
-            kw = PyObject((String=>Any)[string(k) => v for (k, v) in kwargs])
+            kw = PyObject((AbstractString=>Any)[string(k) => v for (k, v) in kwargs])
             ret = PyObject(@pycheckni ccall((@pysym :PyObject_Call), PyPtr,
                                             (PyPtr,PyPtr,PyPtr), o, arg, kw))
         end
@@ -859,7 +859,7 @@ for (mime, method) in ((MIME"text/html", "_repr_html_"),
                        (MIME"image/png", "_repr_png_"),
                        (MIME"image/svg+xml", "_repr_svg_"),
                        (MIME"text/latex", "_repr_latex_"))
-    T = istext(mime()) ? String : Vector{Uint8}
+    T = istext(mime()) ? AbstractString : Vector{Uint8}
     @eval begin
         function writemime(io::IO, mime::$mime, o::PyObject)
             if o.o != C_NULL && haskey(o, $method)
@@ -881,7 +881,7 @@ const pyeval_fname = bytestring("PyCall.jl") # filename for pyeval
 
 # evaluate a python string, returning PyObject, given a dictionary
 # (string/symbol => value) of local variables to use in the expression
-function pyeval_(s::String, locals::PyDict) 
+function pyeval_(s::AbstractString, locals::PyDict) 
     sb = bytestring(s) # use temp var to prevent gc before we are done with o
     sigatomic_begin()
     try
@@ -901,8 +901,8 @@ function pyeval_(s::String, locals::PyDict)
     end
 end
 
-function pyeval(s::String, returntype::TypeTuple=PyAny; kwargs...)
-    locals = PyDict{String,PyObject}()
+function pyeval(s::AbstractString, returntype::TypeTuple=PyAny; kwargs...)
+    locals = PyDict{AbstractString,PyObject}()
     for (k, v) in kwargs
         locals[string(k)] = v
     end

src/callback.jl

@@ -9,7 +9,7 @@
 
 # Define a Python method/function object from f(PyPtr,PyPtr)::PyPtr.
 # Requires f to be a top-level function.
-function pymethod(f::Function, name::String, flags::Integer)
+function pymethod(f::Function, name::AbstractString, flags::Integer)
     # Python expects the PyMethodDef structure to be a *constant*,
     # so we define an anonymous global to hold it.
     def = gensym("PyMethodDef")

src/conversions.jl

@@ -57,7 +57,7 @@ PyObject(s::UTF8String) =
                            PyPtr, (Ptr{Uint8}, Int, Ptr{Uint8}),
                            bytestring(s), sizeof(s), C_NULL))
 
-function PyObject(s::String)
+function PyObject(s::AbstractString)
     @pyinitialize
     if pyunicode_literals::Bool
         sb = bytestring(s)
@@ -70,7 +70,7 @@ function PyObject(s::String)
     end
 end
 
-function convert{T<:String}(::Type{T}, po::PyObject)
+function convert{T<:AbstractString}(::Type{T}, po::PyObject)
     @pyinitialize
     if pyisinstance(po, @pysym :PyUnicode_Type)
         convert(T, PyObject(@pycheckni ccall(PyUnicode_AsUTF8String::Ptr{Void},
@@ -84,7 +84,7 @@ end
 # TODO: should symbols be converted to a subclass of Python strings/bytes,
 #       so that PyAny conversion can convert it back to a Julia symbol?
 PyObject(s::Symbol) = PyObject(string(s))
-convert(::Type{Symbol}, po::PyObject) = symbol(convert(String, po))
+convert(::Type{Symbol}, po::PyObject) = symbol(convert(AbstractString, po))
 
 #########################################################################
 # ByteArray conversions
@@ -158,7 +158,7 @@ pyptr_query(po::PyObject) = pyisinstance(po, c_void_p_Type::PyObject) || pyisins
 
 # I want to use a union, but this seems to confuse Julia's method
 # dispatch for the convert function in some circumstances
-# typealias PyAny Union(PyObject, Int, Bool, Float64, Complex128, String, Function, Dict, Tuple, Array)
+# typealias PyAny Union(PyObject, Int, Bool, Float64, Complex128, AbstractString, Function, Dict, Tuple, Array)
 abstract PyAny
 
 # I originally implemented this via multiple dispatch, with
@@ -168,7 +168,7 @@ pyany_toany(x) = isa(x, Type{PyAny}) ? Any : (isa(x, Tuple) ?
                                               map(pyany_toany, x) : x)
 
 # no-op conversions
-for T in (:PyObject, :Int, :Bool, :Float64, :Complex128, :String, 
+for T in (:PyObject, :Int, :Bool, :Float64, :Complex128, :AbstractString, 
           :Function, :Dict, :Tuple, :Array)
     @eval convert(::Type{PyAny}, x::$T) = x
 end
@@ -448,7 +448,7 @@ haskey(d::PyDict, key) = 1 == ccall(d.isdict ? (@pysym :PyDict_Contains)
                                           : (@pysym :PyMapping_HasKey),
                                   Cint, (PyPtr, PyPtr), d, PyObject(key))
 
-pyobject_call(d::PyDict, vec::String) = PyObject(@pycheckni ccall((@pysym :PyObject_CallMethod), PyPtr, (PyPtr,Ptr{Uint8},Ptr{Uint8}), d, bytestring(vec), C_NULL))
+pyobject_call(d::PyDict, vec::AbstractString) = PyObject(@pycheckni ccall((@pysym :PyObject_CallMethod), PyPtr, (PyPtr,Ptr{Uint8},Ptr{Uint8}), d, bytestring(vec), C_NULL))
 
 keys{T}(::Type{T}, d::PyDict) = convert(Vector{T}, d.isdict ? PyObject(@pycheckni ccall((@pysym :PyDict_Keys), PyPtr, (PyPtr,), d)) : pyobject_call(d, "keys"))
 
@@ -663,7 +663,7 @@ function PyObject(x::Complex{BigFloat})
 end
 
 function convert(::Type{BigFloat}, o::PyObject)
-    BigFloat(convert(String, PyObject(ccall((@pysym :PyObject_Str), 
+    BigFloat(convert(AbstractString, PyObject(ccall((@pysym :PyObject_Str), 
                                             PyPtr, (PyPtr,), o))))
 end
 
@@ -688,7 +688,7 @@ function PyObject(i::BigInt)
 end
 
 function convert(::Type{BigInt}, o::PyObject)
-    BigInt(convert(String, PyObject(ccall((@pysym :PyObject_Str), 
+    BigInt(convert(AbstractString, PyObject(ccall((@pysym :PyObject_Str), 
                                           PyPtr, (PyPtr,), o))))
 end
 
@@ -712,7 +712,7 @@ pyfloat_query(o::PyObject) = pyisinstance(o, @pysym :PyFloat_Type) ? Float64 : N
 pycomplex_query(o::PyObject) = 
   pyisinstance(o, @pysym :PyComplex_Type) ? Complex128 : None
 
-pystring_query(o::PyObject) = pyisinstance(o, pystring_type::Ptr{Void}) ? String : pyisinstance(o, @pysym :PyUnicode_Type) ? UTF8String : None
+pystring_query(o::PyObject) = pyisinstance(o, pystring_type::Ptr{Void}) ? AbstractString : pyisinstance(o, @pysym :PyUnicode_Type) ? UTF8String : None
 
 pyfunction_query(o::PyObject) = pyisinstance(o, @pysym :PyFunction_Type) || pyisinstance(o, BuiltinFunctionType::PyObject) || pyisinstance(o, ufuncType::PyObject) || pyisinstance(o, TypeType::PyObject) || pyisinstance(o, MethodType::PyObject) || pyisinstance(o, MethodWrapperType::PyObject) ? Function : None
 
@@ -741,7 +741,7 @@ function pysequence_query(o::PyObject)
     else
         try
             otypestr = get(o["__array_interface__"], PyObject, "typestr")
-            typestr = convert(String, otypestr)
+            typestr = convert(AbstractString, otypestr)
             T = npy_typestrs[typestr[2:end]]
             if T == PyPtr
                 T = PyObject

src/exception.jl

@@ -2,7 +2,7 @@
 # Wrapper around Python exceptions
 
 type PyError <: Exception
-    msg::String # message string from Julia context, or "" if none
+    msg::AbstractString # message string from Julia context, or "" if none
 
     # info returned by PyErr_Fetch/PyErr_Normalize
     T::PyObject
@@ -12,7 +12,7 @@ type PyError <: Exception
     # generate a PyError object.  Should normally only be called when
     # PyErr_Occurred returns non-NULL, and clears the Python error
     # indicator.  Assumes Python is initialized!
-    function PyError(msg::String)
+    function PyError(msg::AbstractString)
         exc = Array(PyPtr, 3)
         pexc = convert(Uint, pointer(exc))
         # equivalent of passing C pointers &exc[1], &exc[2], &exc[3]:
@@ -38,7 +38,7 @@ function show(io::IO, e::PyError)
     if e.traceback.o != C_NULL
         o = pycall(format_traceback::PyObject, PyObject, e.traceback)
         if o.o != C_NULL
-            for s in PyVector{String}(o)
+            for s in PyVector{AbstractString}(o)
                 print(io, s)
             end
         end
@@ -51,7 +51,7 @@ end
 # call to discard Python exceptions
 pyerr_clear() = ccall((@pysym :PyErr_Clear), Void, ())
 
-function pyerr_check(msg::String, val::Any)
+function pyerr_check(msg::AbstractString, val::Any)
     # note: don't call pyinitialize here since we will
     # only use this in contexts where initialization was already done
     if ccall((@pysym :PyErr_Occurred), PyPtr, ()) != C_NULL
@@ -60,7 +60,7 @@ function pyerr_check(msg::String, val::Any)
     val # the val argument is there just to pass through to the return value
 end
 
-pyerr_check(msg::String) = pyerr_check(msg, nothing)
+pyerr_check(msg::AbstractString) = pyerr_check(msg, nothing)
 pyerr_check() = pyerr_check("")
 
 # Macros for common pyerr_check("Foo", ccall((@pysym :Foo), ...)) pattern.
@@ -121,26 +121,26 @@ type PyIOError <: Exception end
 
 function pyexc_initialize()
     global pyexc
-    exc = [Exception => :PyExc_RuntimeError,
-           ErrorException => :PyExc_RuntimeError,
-           SystemError => :PyExc_SystemError,
-           TypeError => :PyExc_TypeError,
-           ParseError => :PyExc_SyntaxError,
-           ArgumentError => :PyExc_ValueError,
-           KeyError => :PyExc_KeyError,
-           LoadError => :PyExc_ImportError,
-           MethodError => :PyExc_RuntimeError,
-           EOFError => :PyExc_EOFError,
-           BoundsError => :PyExc_IndexError,
-           DivideError => :PyExc_ZeroDivisionError,
-           DomainError => :PyExc_RuntimeError,
-           OverflowError => :PyExc_OverflowError,
-           InexactError => :PyExc_ArithmeticError,
-           MemoryError => :PyExc_MemoryError,
-           StackOverflowError => :PyExc_MemoryError,
-           UndefRefError => :PyExc_RuntimeError,
-           InterruptException => :PyExc_KeyboardInterrupt,
-           PyIOError => :PyExc_IOError]
+    exc = @compat Dict(Exception => :PyExc_RuntimeError,
+                       ErrorException => :PyExc_RuntimeError,
+                       SystemError => :PyExc_SystemError,
+                       TypeError => :PyExc_TypeError,
+                       ParseError => :PyExc_SyntaxError,
+                       ArgumentError => :PyExc_ValueError,
+                       KeyError => :PyExc_KeyError,
+                       LoadError => :PyExc_ImportError,
+                       MethodError => :PyExc_RuntimeError,
+                       EOFError => :PyExc_EOFError,
+                       BoundsError => :PyExc_IndexError,
+                       DivideError => :PyExc_ZeroDivisionError,
+                       DomainError => :PyExc_RuntimeError,
+                       OverflowError => :PyExc_OverflowError,
+                       InexactError => :PyExc_ArithmeticError,
+                       MemoryError => :PyExc_MemoryError,
+                       StackOverflowError => :PyExc_MemoryError,
+                       UndefRefError => :PyExc_RuntimeError,
+                       InterruptException => :PyExc_KeyboardInterrupt,
+                       PyIOError => :PyExc_IOError)
     for (k,v) in exc
         p = convert(Ptr{PyPtr}, pysym_e(v))
         if p != C_NULL

src/io.jl

@@ -214,7 +214,7 @@ end
 function jl_IO_writelines(self_::PyPtr, arg_::PyPtr)
     try
         io = unsafe_pyjlwrap_to_objref(self_)::IO
-        for s in PyVector{String}(pyincref(arg_))
+        for s in PyVector{AbstractString}(pyincref(arg_))
             write(io, s)
         end
         ccall((@pysym :Py_IncRef), Void, (PyPtr,), pynothing::PyPtr)

src/numpy.jl

@@ -58,7 +58,7 @@ function npyinitialize()
     end
 
     # directory for numpy include files to parse
-    inc = pycall(pyimport("numpy")["get_include"], String)
+    inc = pycall(pyimport("numpy")["get_include"], AbstractString)
 
     # Parse __multiarray_api.h to obtain length and meaning of PyArray_API
     try
@@ -209,8 +209,8 @@ type PyArray_Info
     readonly::Bool
 
     function PyArray_Info(a::PyObject)
-        ai = PyDict{String,PyObject}(a["__array_interface__"])
-        typestr = convert(String, ai["typestr"])
+        ai = PyDict{AbstractString,PyObject}(a["__array_interface__"])
+        typestr = convert(AbstractString, ai["typestr"])
         T = npy_typestrs[typestr[2:end]]
         datatuple = convert((Int,Bool), ai["data"])
         sz = convert(Vector{Int}, ai["shape"])