Ticket #346: sabrina-python3-git-trunk.patch

xapian-bindings/python/Makefile.am

@@ -31 +31 @@
 
 # Install as _DATA rather than _SCRIPTS because we don't want to make these
 # executable (they don't have a #! line).
-pkgpylib_DATA = xapian/__init__.py xapian/__init__.pyc xapian/__init__.pyo
+#pkgpylib_DATA = xapian/__init__.py xapian/__init__.pyc xapian/__init__.pyo
+pkgpylib_DATA = xapian/__init__.py xapian/__pycache__/__init__.cpython-32.pyc xapian/__pycache__/__init__.cpython-32.pyo
 
 pkgpylib_LTLIBRARIES = _xapian.la
 
@@ -67 +68 @@
 
 # We "import _xapian" first so that if we fail to import the glue library
 # we don't generate a broken __init__.pyc or __init__.pyo.
-xapian/__init__.pyc: xapian/__init__.py xapian/_xapian$(PYTHON_SO)
+#xapian/__init__.pyc: xapian/__init__.py xapian/_xapian$(PYTHON_SO)
+xapian/__pycache__/__init__.cpython-32.pyc: xapian/__init__.py xapian/_xapian$(PYTHON_SO)
         PYTHONPATH="xapian:$$PYTHONPATH" $(PYTHON) -c "import _xapian"
         PYTHONPATH=".:$$PYTHONPATH" $(PYTHON) -c "import xapian"
 
-xapian/__init__.pyo: xapian/__init__.py xapian/_xapian$(PYTHON_SO)
+#xapian/__init__.pyo: xapian/__init__.py xapian/_xapian$(PYTHON_SO)
+xapian/__pycache__/__init__.cpython-32.pyo: xapian/__init__.py xapian/_xapian$(PYTHON_SO)
         PYTHONPATH="xapian:$$PYTHONPATH" $(PYTHON) -O -c "import _xapian"
         PYTHONPATH=".:$$PYTHONPATH" $(PYTHON) -O -c "import xapian"
 

xapian-bindings/python/smoketest3.py

@@ -261 +261 @@
     expect_query(xapian.Query(xapian.Query.OP_OR, ('foo', 'bar')),
                  '(foo OR bar)')
     expect_query(xapian.Query(xapian.Query.OP_OR, ('foo', 'bar\xa3')),
-                 '(foo OR bar\xc2\xa3)')
-    expect_query(xapian.Query(xapian.Query.OP_OR, ('foo', 'bar\xc2\xa3')),
-                 '(foo OR bar\xc2\xa3)')
+                 '(foo OR bar\u00a3)')
+    expect_query(xapian.Query(xapian.Query.OP_OR, ('foo', 'bar\u00a3')),
+                 '(foo OR bar\u00a3)')
     expect_query(xapian.Query(xapian.Query.OP_OR, 'foo', 'bar'),
                  '(foo OR bar)')
 
     expect_query(qp.parse_query("NOT t\xe9st", qp.FLAG_BOOLEAN + qp.FLAG_PURE_NOT),
-                 "(<alldocuments> AND_NOT Zt\xc3\xa9st@1)")
+                 "(<alldocuments> AND_NOT Zt\u00e9st@1)")
 
     doc = xapian.Document()
     doc.set_data("Unicode with an acc\xe9nt")
     doc.add_posting(stem("out\xe9r"), 1)
-    expect(doc.get_data(), "Unicode with an acc\xe9nt".encode('utf-8'))
-    term = doc.termlist().next().term
-    expect(term, "out\xe9r".encode('utf-8'))
+    expect(doc.get_data(), "Unicode with an acc\u00e9nt")
+    term = next(doc.termlist()).term
+    expect(term, "out\u00e9r")
 
     # Check simple stopper
     stop = xapian.SimpleStopper()

xapian-bindings/python/util.i

@@ -29 +29 @@
 
 /* Wrap get_description() methods as str(). */
 %rename(__str__) get_description;
+%rename(__next__) next;
 
 /* Hide "unsafe" C++ iterator methods. */
 %rename(_allterms_begin) Xapian::Database::allterms_begin;
@@ -166 +167 @@
         PyList_SET_ITEM(retval, idx++, t);
 
 #if PY_VERSION_HEX >= 0x03000000
-        PyObject * str = PyBytes_FromStringAndSize((*i).data(), (*i).size());
+        PyObject * str = PyUnicode_FromStringAndSize((*i).data(), (*i).size());
 #else
         PyObject * str = PyString_FromStringAndSize((*i).data(), (*i).size());
 #endif
@@ -279 +280 @@
     }
 }
 
-%fragment("XapianSWIG_anystring_as_ptr", "header", fragment="SWIG_AsPtr_std_string") {
+%fragment("XapianBytes_AsCharPtrAndSize","header",fragment="SWIG_pchar_descriptor") {
+SWIGINTERN int
+XapianBytes_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
+{
+%#if PY_VERSION_HEX>=0x03000000
+  if (PyBytes_Check(obj))
+%#else  
+  if (PyString_Check(obj))
+%#endif
+  {
+    char *cstr; Py_ssize_t len;
+%#if PY_VERSION_HEX>=0x03000000
+    if (!alloc && cptr) {
+        /* We can't allow converting without allocation, since the internal
+           representation of string in Python 3 is UCS-2/UCS-4 but we require
+           a UTF-8 representation.
+           TODO(bhy) More detailed explanation */
+        return SWIG_RuntimeError;
+    }
+    PyBytes_AsStringAndSize(obj, &cstr, &len);
+    if(alloc) *alloc = SWIG_NEWOBJ;
+%#else
+    PyString_AsStringAndSize(obj, &cstr, &len);
+%#endif
+    if (cptr) {
+      if (alloc) {
+        /* 
+           In python the user should not be able to modify the inner
+           string representation. To warranty that, if you define
+           SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
+           buffer is always returned.
+
+           The default behavior is just to return the pointer value,
+           so, be careful.
+        */ 
+%#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
+        if (*alloc != SWIG_OLDOBJ) 
+%#else
+        if (*alloc == SWIG_NEWOBJ) 
+%#endif
+          {
+            *cptr = %new_copy_array(cstr, len + 1, char);
+            *alloc = SWIG_NEWOBJ;
+          }
+        else {
+          *cptr = cstr;
+          *alloc = SWIG_OLDOBJ;
+        }
+      } else {
+        %#if PY_VERSION_HEX>=0x03000000
+        assert(0); /* Should never reach here in Python 3 */
+        %#endif
+        *cptr = SWIG_Python_str_AsChar(obj);
+      }
+    }
+    if (psize) *psize = len + 1;
+%#if PY_VERSION_HEX>=0x03000000
+    Py_XDECREF(obj);
+%#endif
+    return SWIG_OK;
+  } else {
+    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+    if (pchar_descriptor) {
+      void* vptr = 0;
+      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
+        if (cptr) *cptr = (char *) vptr;
+        if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
+        if (alloc) *alloc = SWIG_OLDOBJ;
+        return SWIG_OK;
+      }
+    }
+  }
+  return SWIG_TypeError;
+}
+}
+
+%fragment("XapianBytes_AsPtr_std_string","header",fragment="XapianBytes_AsCharPtrAndSize") {
+SWIGINTERN int
+XapianBytes_AsPtr_std_string (PyObject * obj, std::string **val) 
+{
+  char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
+  if (SWIG_IsOK((XapianBytes_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
+    if (buf) {
+      if (val) *val = new std::string(buf, size - 1);
+      if (alloc == SWIG_NEWOBJ) delete[] buf;
+      return SWIG_NEWOBJ;
+    } else {
+      if (val) *val = 0;
+      return SWIG_OLDOBJ;
+    }
+  } else {
+    static int init = 0;
+    static swig_type_info* descriptor = 0;
+    if (!init) {
+      descriptor = SWIG_TypeQuery("std::string" " *");
+      init = 1;
+    }
+    if (descriptor) {
+      std::string *vptr;
+      int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
+      if (SWIG_IsOK(res) && val) *val = vptr;
+      return res;
+    }
+  }
+  return SWIG_ERROR;
+}
+}
+
+%fragment("XapianSWIG_anystring_as_ptr", "header", fragment="SWIG_AsPtr_std_string", fragment="XapianBytes_AsPtr_std_string") {
 /* Utility function which works like SWIG_AsPtr_std_string, but
  * converts unicode strings to UTF-8 simple strings first. */
 static int
 XapianSWIG_anystring_as_ptr(PyObject ** obj, std::string **val)
 {
-    if (PyUnicode_Check(*obj)) {
-        PyObject * strobj = PyUnicode_EncodeUTF8(PyUnicode_AS_UNICODE(*obj), PyUnicode_GET_SIZE(*obj), "ignore");
-        if (strobj == NULL) return SWIG_ERROR;
-        int res = SWIG_AsPtr_std_string(strobj, val);
-        Py_DECREF(strobj);
-        return res;
+    if (PyBytes_Check(*obj)) {
+      return XapianBytes_AsPtr_std_string(*obj, val);  //deal with PyBytes
+   }
+   else {
+     return SWIG_AsPtr_std_string(*obj, val);  //deal with PyUnicode in Python3 and PyString in Python 2.x
+   }
+}
+}
+
+%fragment("XapianBytes_FromCharPtrAndSize","header",fragment="SWIG_pchar_descriptor") {
+PyObject *
+XapianBytes_FromCharPtrAndSize(const char* carray, size_t size)
+{
+  if (carray) {
+    if (size > INT_MAX) {
+      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
+      return pchar_descriptor ? 
+        SWIG_InternalNewPointerObj(%const_cast(carray,char *), pchar_descriptor, 0) : SWIG_Py_Void();
     } else {
-        return SWIG_AsPtr_std_string(*obj, val);
+%#if PY_VERSION_HEX >= 0x03000000
+      return PyBytes_FromStringAndSize(carray, %numeric_cast(size,int));
+%#else
+      return PyString_FromStringAndSize(carray, %numeric_cast(size,int));
+%#endif
     }
+  } else {
+    return SWIG_Py_Void();
+  }
 }
 }
 
+%inline %{
+typedef std::string pybytes;
+%}
+
+
+%typemap(out,fragment="XapianBytes_FromCharPtrAndSize") pybytes {
+    $result = XapianBytes_FromCharPtrAndSize(static_cast< std::string >($1).data(),static_cast< std::string >($1).size());
+}
+%ignore  sortable_serialise;
+%rename(sortable_serialise) Xapian::wrap_sortable_serialise;
+%inline %{
+namespace Xapian {
+pybytes wrap_sortable_serialise(double value) {
+  return Xapian::sortable_serialise(value);
+}  
+} 
+%}
+
 /* These typemaps depends somewhat heavily on the internals of SWIG, so
  * might break with future versions of SWIG.
  */
@@ -459 +605 @@
 
     for (size_t i = 0; i != num_tags; ++i) {
 %#if PY_VERSION_HEX >= 0x03000000
-        PyObject * str = PyBytes_FromStringAndSize(tags[i].data(), tags[i].size());
+        PyObject * str = PyUnicode_FromStringAndSize(tags[i].data(), tags[i].size());
 %#else
         PyObject * str = PyString_FromStringAndSize(tags[i].data(), tags[i].size());
 %#endif