document/export pybytes

Author: stevengj

README.md

@@ -143,7 +143,7 @@ A macro exists for mimicking Python's "with statement". For example:
 The type of `f` can be specified with `f::T` (for example, to override automatic
 conversion, use `f::PyObject`). Similarly, if the context manager returns a type
 which is automatically converted to a Julia type, you will have override this
-via `@pywith EXPR::PyObject ...`. 
+via `@pywith EXPR::PyObject ...`.
 
 
 **Important:** The biggest difference from Python is that object attributes/members are
@@ -230,6 +230,10 @@ and since NumPy supports column-major arrays this is not a problem.
 
 However, the *default* ordering of NumPy arrays created in *Python* is row-major, and some Python packages will throw an error if you try to pass them column-major NumPy arrays.  To deal with this, you can use `PyReverseDims(a)` to pass a Julia array as a row-major NumPy array with the dimensions *reversed*. For example, if `a` is a 3x4x5 Julia array, then `PyReverseDims(a)` passes it as a 5x4x3 NumPy row-major array (without making a copy of the underlying data).
 
+A `Vector{UInt8}` object in Julia, by default, is converted to a Python
+`bytearray` object.   If you want a `bytes` object instead, you can use
+the function `pybytes(a)`.
+
 ##### From Python to Julia
 
 Multidimensional NumPy arrays (`ndarray`) are supported and can be

src/PyCall.jl

@@ -8,7 +8,7 @@ export pycall, pyimport, pybuiltin, PyObject, PyReverseDims,
        pyisinstance, pywrap, pytypeof, pyeval, PyVector, pystring,
        pyraise, pytype_mapping, pygui, pygui_start, pygui_stop,
        pygui_stop_all, @pylab, set!, PyTextIO, @pysym, PyNULL, @pydef,
-       pyimport_conda, @py_str, @pywith, @pycall
+       pyimport_conda, @py_str, @pywith, @pycall, pybytes
 
 import Base: size, ndims, similar, copy, getindex, setindex!, stride,
        convert, pointer, summary, convert, show, haskey, keys, values,

src/serialize.jl

@@ -12,9 +12,17 @@ function Base.serialize(s::AbstractSerializer, pyo::PyObject)
     end
 end
 
-pybytes(b) = PyObject(@pycheckn ccall(@pysym(PyString_FromStringAndSize),
-                                      PyPtr, (Ptr{UInt8}, Int),
-                                      b, sizeof(b)))
+"""
+    pybytes(b::Union{String,Vector{UInt8}})
+
+Convert `b` to a Python `bytes` object.   This differs from the default
+`PyObject(b)` conversion of `String` to a Python string (which may fail if `b`
+does not contain valid Unicode), or from the default conversion of a
+`Vector{UInt8}` to a `bytearray` object (which is mutable, unlike `bytes`).
+"""
+pybytes(b::Union{String,Array{UInt8}}) = PyObject(@pycheckn ccall(@pysym(PyString_FromStringAndSize),
+                                                  PyPtr, (Ptr{UInt8}, Int),
+                                                  b, sizeof(b)))
 
 function Base.deserialize(s::AbstractSerializer, t::Type{PyObject})
     b = deserialize(s)

test/runtests.jl

@@ -430,3 +430,7 @@ end
 
 @test contains(Base.Docs.doc(PyObject(1)).content, "integer")
 @test contains(Base.Docs.doc(PyObject(py"lambda x: x+1")).content, "no docstring")
+
+let b = rand(UInt8, 1000)
+    @test Vector{UInt8}(pybytes(b)) == b == Vector{UInt8}(pybytes(String(b)))
+end