From 5f7d1e9d5b7524c8f9c35a78fb46ab814433a2b78019756623125c23020628e6 Mon Sep 17 00:00:00 2001 From: Todd R Date: Wed, 2 May 2012 14:06:38 +0000 Subject: [PATCH] Accepting request 116121 from home:HighwayStar:branches:devel:languages:python python3 package added, python2 slightly cleaned (old buildroot macro replaced) OBS-URL: https://build.opensuse.org/request/show/116121 OBS-URL: https://build.opensuse.org/package/show/devel:languages:python/python-pycurl?expand=0&rev=9 --- pycurl-python3.patch | 1015 ++++++++++++++++++++++++++++++++++++++++ python-pycurl.changes | 6 + python-pycurl.spec | 3 +- python3-pycurl.changes | 6 + python3-pycurl.spec | 78 +++ 5 files changed, 1107 insertions(+), 1 deletion(-) create mode 100644 pycurl-python3.patch create mode 100644 python3-pycurl.changes create mode 100644 python3-pycurl.spec diff --git a/pycurl-python3.patch b/pycurl-python3.patch new file mode 100644 index 0000000..b8467b3 --- /dev/null +++ b/pycurl-python3.patch @@ -0,0 +1,1015 @@ +diff -ruN ./examples/basicfirst.py ../pycurl-7.19.0.test/examples/basicfirst.py +--- ./examples/basicfirst.py 2005-02-11 19:09:11.000000000 +0800 ++++ ../pycurl-7.19.0.test/examples/basicfirst.py 2012-04-28 15:30:41.041273003 +0900 +@@ -13,13 +13,17 @@ + def body_callback(self, buf): + self.contents = self.contents + buf + +-print >>sys.stderr, 'Testing', pycurl.version ++#print('Testing', pycurl.version, file=sys.stderr) + +-t = Test() +-c = pycurl.Curl() +-c.setopt(c.URL, 'http://curl.haxx.se/dev/') +-c.setopt(c.WRITEFUNCTION, t.body_callback) +-c.perform() +-c.close() ++try: ++ t = Test() ++ c = pycurl.Curl() ++ c.setopt(c.URL, sys.argv[1]) ++ c.setopt(c.WRITEFUNCTION, t.body_callback) ++ c.perform() ++ c.close() ++# print(t) ++ print(t.contents) ++except Exception as e: ++ print(e) + +-print t.contents +diff -ruN ./examples/retriever-multi.py ../pycurl-7.19.0.test/examples/retriever-multi.py +--- ./examples/retriever-multi.py 2005-07-28 20:04:13.000000000 +0900 ++++ ../pycurl-7.19.0.test/examples/retriever-multi.py 2012-04-28 15:10:34.768799001 +0900 +@@ -10,6 +10,7 @@ + + import sys + import pycurl ++import time + + # We should ignore SIGPIPE when using pycurl.NOSIGNAL - see + # the libcurl tutorial for more info. +@@ -31,7 +32,7 @@ + if len(sys.argv) >= 3: + num_conn = int(sys.argv[2]) + except: +- print "Usage: %s [<# of concurrent connections>]" % sys.argv[0] ++ print("Usage: %s [<# of concurrent connections>]" % sys.argv[0]) + raise SystemExit + + +@@ -50,8 +51,8 @@ + num_urls = len(queue) + num_conn = min(num_conn, num_urls) + assert 1 <= num_conn <= 10000, "invalid number of concurrent connections" +-print "PycURL %s (compiled against 0x%x)" % (pycurl.version, pycurl.COMPILE_LIBCURL_VERSION_NUM) +-print "----- Getting", num_urls, "URLs using", num_conn, "connections -----" ++print("PycURL %s (compiled against 0x%x)" % (pycurl.version, pycurl.COMPILE_LIBCURL_VERSION_NUM)) ++print("----- Getting", num_urls, "URLs using", num_conn, "connections -----") + + + # Pre-allocate a list of curl objects +@@ -79,6 +80,9 @@ + c.fp = open(filename, "wb") + c.setopt(pycurl.URL, url) + c.setopt(pycurl.WRITEDATA, c.fp) ++# print(c.fp) ++# c.fp.close() ++# c.fp = None + m.add_handle(c) + # store some info + c.filename = filename +@@ -92,16 +96,17 @@ + while 1: + num_q, ok_list, err_list = m.info_read() + for c in ok_list: ++ c.fp.flush() + c.fp.close() + c.fp = None + m.remove_handle(c) +- print "Success:", c.filename, c.url, c.getinfo(pycurl.EFFECTIVE_URL) ++ print("Success:", c.filename, c.url, c.getinfo(pycurl.EFFECTIVE_URL)) + freelist.append(c) + for c, errno, errmsg in err_list: + c.fp.close() + c.fp = None + m.remove_handle(c) +- print "Failed: ", c.filename, c.url, errno, errmsg ++ print("Failed: ", c.filename, c.url, errno, errmsg) + freelist.append(c) + num_processed = num_processed + len(ok_list) + len(err_list) + if num_q == 0: +@@ -120,3 +125,4 @@ + c.close() + m.close() + ++#time.sleep(30) +diff -ruN ./setup.py ../pycurl-7.19.0.test/setup.py +--- ./setup.py 2012-04-28 15:05:16.000000000 +0900 ++++ ../pycurl-7.19.0.test/setup.py 2012-04-28 15:10:34.768799001 +0900 +@@ -31,7 +31,7 @@ + i = 1 + while i < len(sys.argv): + arg = sys.argv[i] +- if string.find(arg, s) == 0: ++ if str.find(arg, s) == 0: + p = arg[len(s):] + assert p, arg + del sys.argv[i] +@@ -46,8 +46,8 @@ + v = os.environ.get(envvar) + if not v: + return +- for dir in string.split(v, sep): +- dir = string.strip(dir) ++ for dir in str.split(v, sep): ++ dir = str.strip(dir) + if not dir: + continue + dir = os.path.normpath(dir) +@@ -55,7 +55,7 @@ + if not dir in library_dirs: + library_dirs.append(dir) + elif fatal: +- print "FATAL: bad directory %s in environment variable %s" % (dir, envvar) ++ print("FATAL: bad directory %s in environment variable %s" % (dir, envvar)) + sys.exit(1) + + +@@ -65,13 +65,13 @@ + # and thus unlikely to match your installation. + CURL_DIR = r"c:\src\build\pycurl\curl-7.16.2.1" + CURL_DIR = scan_argv("--curl-dir=", CURL_DIR) +- print "Using curl directory:", CURL_DIR ++ print("Using curl directory:", CURL_DIR) + assert os.path.isdir(CURL_DIR), "please check CURL_DIR in setup.py" + include_dirs.append(os.path.join(CURL_DIR, "include")) + extra_objects.append(os.path.join(CURL_DIR, "lib", "libcurl.lib")) + extra_link_args.extend(["gdi32.lib", "wldap32.lib", "winmm.lib", "ws2_32.lib",]) + add_libdirs("LIB", ";") +- if string.find(sys.version, "MSC") >= 0: ++ if str.find(sys.version, "MSC") >= 0: + extra_compile_args.append("-O2") + extra_compile_args.append("-GF") # enable read-only string pooling + extra_compile_args.append("-WX") # treat warnings as errors +@@ -85,10 +85,10 @@ + CURL_CONFIG = scan_argv("--curl-config=", CURL_CONFIG) + d = os.popen("'%s' --version" % CURL_CONFIG).read() + if d: +- d = string.strip(d) ++ d = str.strip(d) + if not d: +- raise Exception, ("`%s' not found -- please install the libcurl development files" % CURL_CONFIG) +- print "Using %s (%s)" % (CURL_CONFIG, d) ++ raise Exception("`%s' not found -- please install the libcurl development files" % CURL_CONFIG) ++ print("Using %s (%s)" % (CURL_CONFIG, d)) + for e in split_quoted(os.popen("'%s' --cflags" % CURL_CONFIG).read()): + if e[:2] == "-I": + # do not add /usr/include +@@ -208,4 +208,4 @@ + for o in ext.extra_objects: + assert os.path.isfile(o), o + # We can live with the deprecationwarning for a while +- apply(setup, (), setup_args) ++ setup(*(), **setup_args) +diff -ruN ./src/pycurl.c ../pycurl-7.19.0.test/src/pycurl.c +--- ./src/pycurl.c 2008-09-10 02:40:34.000000000 +0900 ++++ ../pycurl-7.19.0.test/src/pycurl.c 2012-04-28 15:18:26.302305002 +0900 +@@ -94,6 +94,17 @@ + static void pycurl_ssl_cleanup(void); + #endif + ++#if PY_MAJOR_VERSION < 3 ++#define Py_TYPE(x) (x)->ob_type ++#endif ++ ++#if PY_MAJOR_VERSION >= 3 ++ #define PyInt_Type PyLong_Type ++ #define PyInt_Check(op) PyLong_Check(op) ++ #define PyInt_FromLong PyLong_FromLong ++ #define PyInt_AsLong PyLong_AsLong ++#endif ++ + /* Calculate the number of OBJECTPOINT options we need to store */ + #define OPTIONS_SIZE ((int)CURLOPT_LASTENTRY % 10000) + #define MOPTIONS_SIZE ((int)CURLMOPT_LASTENTRY % 10000) +@@ -158,6 +169,7 @@ + PyObject *opensocket_cb; + /* file objects */ + PyObject *readdata_fp; ++ PyObject *writedata; + PyObject *writedata_fp; + PyObject *writeheader_fp; + /* misc */ +@@ -199,16 +211,46 @@ + # define PY_LONG_LONG LONG_LONG + #endif + ++int PyUnicode_AsStringAndSize(PyObject *obj, char **buffer, Py_ssize_t *length) ++{ ++ Py_ssize_t pysize = PyUnicode_GetSize(obj); ++ wchar_t * str = (wchar_t *) malloc((pysize + 1) * sizeof(wchar_t)); ++ PyUnicode_AsWideChar((PyUnicodeObject *) obj, str, pysize); ++ str[pysize] = '\0'; ++ ++// measure size ++ size_t csize = wcstombs(0, str, 0); ++ if( csize == (size_t) -1 ) ++ { ++ free(str); ++ return -1; ++ } ++ ++ char *cstr = (char *) malloc(csize + 1); ++ ++// convert ++ wcstombs(cstr, str, csize + 1); ++ *buffer = cstr; ++ if( length ) ++ *length = csize; ++ free(str); ++ return 0; ++} ++ ++ + /* Like PyString_AsString(), but set an exception if the string contains + * embedded NULs. Actually PyString_AsStringAndSize() already does that for + * us if the `len' parameter is NULL - see Objects/stringobject.c. + */ +- + static char *PyString_AsString_NoNUL(PyObject *obj) + { + char *s = NULL; + Py_ssize_t r; ++#if PY_MAJOR_VERSION >= 3 ++ r = PyUnicode_AsStringAndSize(obj, &s, NULL); ++#else + r = PyString_AsStringAndSize(obj, &s, NULL); ++#endif + if (r != 0) + return NULL; /* exception already set */ + assert(s != NULL); +@@ -233,7 +275,11 @@ + if (slist->data == NULL) { + v = Py_None; Py_INCREF(v); + } else { ++#if PY_MAJOR_VERSION >= 3 ++ v = PyUnicode_FromString(slist->data); ++#else + v = PyString_FromString(slist->data); ++#endif + } + if (v == NULL || PyList_Append(ret, v) != 0) { + Py_XDECREF(v); +@@ -269,7 +315,7 @@ + */ + if (self == NULL) + return NULL; +- assert(self->ob_type == p_Curl_Type); ++ assert(Py_TYPE(self) == p_Curl_Type); + if (self->state != NULL) + { + /* inside perform() */ +@@ -299,7 +345,7 @@ + */ + if (self == NULL) + return NULL; +- assert(self->ob_type == p_CurlMulti_Type); ++ assert(Py_TYPE(self) == p_CurlMulti_Type); + if (self->state != NULL) + { + /* inside multi_perform() */ +@@ -315,7 +361,7 @@ + assert_share_state(const CurlShareObject *self) + { + assert(self != NULL); +- assert(self->ob_type == p_CurlShare_Type); ++ assert(Py_TYPE(self) == p_CurlShare_Type); + assert(self->lock != NULL); + } + +@@ -325,7 +371,7 @@ + assert_curl_state(const CurlObject *self) + { + assert(self != NULL); +- assert(self->ob_type == p_Curl_Type); ++ assert(Py_TYPE(self) == p_Curl_Type); + (void) get_thread_state(self); + } + +@@ -335,7 +381,7 @@ + assert_multi_state(const CurlMultiObject *self) + { + assert(self != NULL); +- assert(self->ob_type == p_CurlMulti_Type); ++ assert(Py_TYPE(self) == p_CurlMulti_Type); + if (self->state != NULL) { + assert(self->multi_handle != NULL); + } +@@ -553,6 +599,7 @@ + share_lock_unlock(share->lock, data); + } + ++size_t default_write_callback(char *ptr, size_t size, size_t nmemb, void *stream); + + /* constructor - this is a module-level function returning a new instance */ + static CurlShareObject * +@@ -673,7 +720,8 @@ + + /* Handle the case of integer arguments */ + if (PyInt_Check(obj)) { +- long d = PyInt_AsLong(obj); ++ long d = PyLong_AsLong(obj); ++ + if (d != CURL_LOCK_DATA_COOKIE && d != CURL_LOCK_DATA_DNS) { + goto error; + } +@@ -806,11 +854,23 @@ + } + self->options[ OPT_INDEX(CURLOPT_USERAGENT) ] = s; s = NULL; + ++ ++#if PY_MAJOR_VERSION >= 3 ++ res = curl_easy_setopt(self->handle, CURLOPT_WRITEFUNCTION, default_write_callback); ++ if (res != CURLE_OK) { ++ goto error; ++ } ++ res = curl_easy_setopt(self->handle, CURLOPT_WRITEDATA, self); ++ if (res != CURLE_OK) { ++ goto error; ++ } ++#endif ++ + /* Success - return new object */ + return self; + + error: +- Py_DECREF(self); /* this also closes self->handle */ ++ Py_XDECREF(self); /* this also closes self->handle */ + PyErr_SetString(ErrorObject, "initializing curl failed"); + return NULL; + } +@@ -877,7 +937,7 @@ + /* Zero handle and thread-state to disallow any operations to be run + * from now on */ + assert(self != NULL); +- assert(self->ob_type == p_Curl_Type); ++ assert(Py_TYPE(self) == p_Curl_Type); + handle = self->handle; + self->handle = NULL; + if (handle == NULL) { +@@ -962,7 +1022,12 @@ + return NULL; + } + self->error[sizeof(self->error) - 1] = 0; ++ ++#if PY_MAJOR_VERSION >= 3 ++ return PyUnicode_FromString(self->error); ++#else + return PyString_FromString(self->error); ++#endif + } + + +@@ -1122,6 +1187,52 @@ + return util_write_callback(0, ptr, size, nmemb, stream); + } + ++ ++size_t ++default_write_callback(char *ptr, size_t size, size_t nmemb, void *stream) ++{ ++ CurlObject *obj = (CurlObject *)stream; ++ PyThreadState *tmp_state; ++ CurlObject *self = (CurlObject *)stream; ++ ++ /* acquire thread */ ++ int ret = 0; ++ tmp_state = get_thread_state(self); ++ if (tmp_state == NULL) ++ return ret; ++ PyEval_AcquireThread(tmp_state); ++ ++ if(obj->writedata_fp != NULL) ++ { ++ /** ++ * I'd prefer this code, but ++ * PyFile_WriteObject converts the object to str or repr, which are of type str ++ * and the write() fn expects bytes or buffer ... ++ */ ++/* ++ PyObject *w = PyBytes_FromStringAndSize(ptr, size*nmemb); ++ printf("writedata_fp %p w %p s %i\n", obj->writedata_fp, w, PyBytes_GET_SIZE(w)); ++ Py_INCREF(w); ++ if( PyFile_WriteObject(w, obj->writedata_fp, Py_PRINT_RAW) != 0 ) ++ { ++ PyErr_Print(); ++ ret = -1; ++ } ++ ++ Py_DECREF(w); ++*/ ++ int fd = PyObject_AsFileDescriptor(((CurlObject *)stream)->writedata_fp); ++ ret = write(fd, ptr, size*nmemb); ++ }else ++ { ++ fwrite(ptr, size, nmemb, stdout); ++ } ++ ++ PyEval_ReleaseThread(tmp_state); ++ return ret; ++} ++ ++ + static size_t + header_callback(char *ptr, size_t size, size_t nmemb, void *stream) + { +@@ -1163,6 +1274,7 @@ + ret = CURL_SOCKET_BAD; + goto verbose_error; + } ++ + // normal operation: + if (PyInt_Check(fileno_result)) { + ret = dup(PyInt_AsLong(fileno_result)); +@@ -1224,11 +1336,19 @@ + goto verbose_error; + + /* handle result */ ++#if PY_MAJOR_VERSION >= 3 ++ if (PyBytes_Check(result)) { ++#else + if (PyString_Check(result)) { ++#endif + char *buf = NULL; + Py_ssize_t obj_size = -1; + Py_ssize_t r; ++#if PY_MAJOR_VERSION >= 3 ++ r = PyBytes_AsStringAndSize(result, &buf, &obj_size); ++#else + r = PyString_AsStringAndSize(result, &buf, &obj_size); ++#endif + if (r != 0 || obj_size < 0 || obj_size > total_size) { + PyErr_Format(ErrorObject, "invalid return value for read callback %ld %ld", (long)obj_size, (long)total_size); + goto verbose_error; +@@ -1401,6 +1521,7 @@ + if (result == Py_None) { + ret = CURLIOE_OK; /* None means success */ + } ++ + else if (PyInt_Check(result)) { + ret = (int) PyInt_AsLong(result); + if (ret >= CURLIOE_LAST || ret < 0) { +@@ -1584,7 +1705,11 @@ + #endif + + /* Handle the case of string arguments */ ++#if PY_MAJOR_VERSION >= 3 ++ if (PyUnicode_Check(obj)) { ++#else + if (PyString_Check(obj)) { ++#endif + char *str = NULL; + Py_ssize_t len = -1; + char *buf; +@@ -1633,8 +1758,13 @@ + return NULL; + break; + case CURLOPT_POSTFIELDS: ++#if PY_MAJOR_VERSION >= 3 ++ if (PyUnicode_AsStringAndSize(obj, &str, &len) != 0) ++ return NULL; ++#else + if (PyString_AsStringAndSize(obj, &str, &len) != 0) + return NULL; ++#endif + /* automatically set POSTFIELDSIZE */ + if (len <= INT_MAX) { + res = curl_easy_setopt(self->handle, CURLOPT_POSTFIELDSIZE, (long)len); +@@ -1683,7 +1813,6 @@ + /* Handle the case of integer arguments */ + if (PyInt_Check(obj)) { + long d = PyInt_AsLong(obj); +- + if (IS_LONG_OPTION(option)) + res = curl_easy_setopt(self->handle, (CURLoption)option, (long)d); + else if (IS_OFF_T_OPTION(option)) +@@ -1724,7 +1853,12 @@ + #undef IS_OFF_T_OPTION + + /* Handle the case of file objects */ ++#if PY_MAJOR_VERSION >= 3 ++ extern PyTypeObject PyIOBase_Type; ++ if(PyObject_IsInstance(obj, (PyObject *)&PyIOBase_Type) == 1) { ++#else + if (PyFile_Check(obj)) { ++#endif + FILE *fp; + + /* Ensure the option specified a file as well as the input */ +@@ -1742,7 +1876,12 @@ + PyErr_SetString(PyExc_TypeError, "files are not supported for this option"); + return NULL; + } +- ++#if PY_MAJOR_VERSION >= 3 ++// printf("WRITEDATA %p\n",obj); ++// int fd = PyObject_AsFileDescriptor(obj); ++// printf("fd is %i\n", fd); ++// fp = fdopen(fd, "w"); ++#else + fp = PyFile_AsFile(obj); + if (fp == NULL) { + PyErr_SetString(PyExc_TypeError, "second argument must be open file"); +@@ -1752,6 +1891,7 @@ + if (res != CURLE_OK) { + CURLERROR_RETVAL(); + } ++#endif + Py_INCREF(obj); + + switch (option) { +@@ -1841,14 +1981,27 @@ + PyErr_SetString(PyExc_TypeError, "tuple must contain two elements (name, value)"); + return NULL; + } ++#if PY_MAJOR_VERSION >= 3 ++ if (PyUnicode_AsStringAndSize(PyTuple_GET_ITEM(listitem, 0), &nstr, &nlen) != 0) { ++#else + if (PyString_AsStringAndSize(PyTuple_GET_ITEM(listitem, 0), &nstr, &nlen) != 0) { ++#endif + curl_formfree(post); + PyErr_SetString(PyExc_TypeError, "tuple must contain string as first element"); + return NULL; + } ++#if PY_MAJOR_VERSION >= 3 ++ if (PyUnicode_Check(PyTuple_GET_ITEM(listitem, 1))) { ++#else + if (PyString_Check(PyTuple_GET_ITEM(listitem, 1))) { ++#endif + /* Handle strings as second argument for backwards compatibility */ ++ ++#if PY_MAJOR_VERSION >= 3 ++ PyUnicode_AsStringAndSize(PyTuple_GET_ITEM(listitem, 1), &cstr, &clen); ++#else + PyString_AsStringAndSize(PyTuple_GET_ITEM(listitem, 1), &cstr, &clen); ++#endif + /* INFO: curl_formadd() internally does memdup() the data, so + * embedded NUL characters _are_ allowed here. */ + res = curl_formadd(&post, &last, +@@ -1902,7 +2055,11 @@ + curl_formfree(post); + return NULL; + } ++#if PY_MAJOR_VERSION >= 3 ++ if (!PyUnicode_Check(PyTuple_GET_ITEM(t, j+1))) { ++#else + if (!PyString_Check(PyTuple_GET_ITEM(t, j+1))) { ++#endif + PyErr_SetString(PyExc_TypeError, "value must be string"); + PyMem_Free(forms); + curl_formfree(post); +@@ -1920,7 +2077,11 @@ + curl_formfree(post); + return NULL; + } ++#if PY_MAJOR_VERSION >= 3 ++ PyUnicode_AsStringAndSize(PyTuple_GET_ITEM(t, j+1), &ostr, &olen); ++#else + PyString_AsStringAndSize(PyTuple_GET_ITEM(t, j+1), &ostr, &olen); ++#endif + forms[k].option = val; + forms[k].value = ostr; + ++k; +@@ -1972,7 +2133,11 @@ + struct curl_slist *nlist; + char *str; + ++#if PY_MAJOR_VERSION >= 3 ++ if (!PyUnicode_Check(listitem)) { ++#else + if (!PyString_Check(listitem)) { ++#endif + curl_slist_free_all(slist); + PyErr_SetString(PyExc_TypeError, "list items must be string objects"); + return NULL; +@@ -2187,7 +2352,12 @@ + Py_INCREF(Py_None); + return Py_None; + } ++#if PY_MAJOR_VERSION >= 3 ++ return PyUnicode_FromString(s_res); ++#else + return PyString_FromString(s_res); ++#endif ++ + } + + case CURLINFO_CONNECT_TIME: +@@ -2846,7 +3016,7 @@ + Py_DECREF(ok_list); + CURLERROR_MSG("Unable to fetch curl handle from curl object"); + } +- assert(co->ob_type == p_Curl_Type); ++ assert(Py_TYPE(co) == p_Curl_Type); + if (msg->msg != CURLMSG_DONE) { + /* FIXME: what does this mean ??? */ + } +@@ -2927,7 +3097,6 @@ + * socket code to report any errors. + */ + } +- + return PyInt_FromLong(n); + } + +@@ -2992,6 +3161,116 @@ + static PyObject *curlmultiobject_constants = NULL; + static PyObject *curlshareobject_constants = NULL; + ++ ++#if PY_MAJOR_VERSION >= 3 ++static PyObject * ++my_getattro(PyObject *co, PyObject *name, PyObject *dict1, PyObject *dict2, PyMethodDef *m) ++{ ++ PyObject *v = NULL; ++ if( v == NULL && dict1 != NULL ) ++ v = PyDict_GetItem(dict1, name); ++ if( v == NULL && dict2 != NULL ) ++ v = PyDict_GetItem(dict2, name); ++ if( v != NULL ) ++ { ++ Py_INCREF(v); ++ return v; ++ } ++ return NULL; ++} ++ ++static int ++my_setattro(PyObject **dict, PyObject *name, PyObject *v) ++{ ++ if( *dict == NULL ) ++ { ++ *dict = PyDict_New(); ++ if( *dict == NULL ) ++ return -1; ++ } ++ return PyDict_SetItem(*dict, name, v); ++} ++ ++PyObject *do_curl_getattro(PyObject *o, PyObject *n) ++{ ++ PyObject *v = PyObject_GenericGetAttr(o, n); ++ if( !v && PyErr_ExceptionMatches(PyExc_AttributeError) ) ++ { ++ PyErr_Clear(); ++ v = my_getattro(o, n, ((CurlObject *)o)->dict, ++ curlobject_constants, curlobject_methods); ++ } ++ return v; ++} ++ ++static int ++do_curl_setattro(PyObject *o, PyObject *name, PyObject *v) ++{ ++ assert_curl_state((CurlObject *)o); ++ if( v ) ++ { ++ return my_setattro(&((CurlObject *)o)->dict, name, v); ++ } else ++ { ++ return PyObject_GenericSetAttr(o, name, 0); ++ } ++} ++ ++static PyObject * ++do_multi_getattro(PyObject *o, PyObject *n) ++{ ++ assert_multi_state((CurlMultiObject *)o); ++ PyObject *v = PyObject_GenericGetAttr(o, n); ++ if( !v && PyErr_ExceptionMatches(PyExc_AttributeError) ) ++ { ++ PyErr_Clear(); ++ v = my_getattro(o, n, ((CurlMultiObject *)o)->dict, ++ curlmultiobject_constants, curlmultiobject_methods); ++ } ++ return v; ++} ++ ++static int ++do_multi_setattro(PyObject *o, PyObject *n, PyObject *v) ++{ ++ assert_multi_state((CurlMultiObject *)o); ++ if( v ) ++ { ++ return my_setattro(&((CurlMultiObject *)o)->dict, n, v); ++ } else ++ { ++ return PyObject_GenericSetAttr(o, n, 0); ++ } ++} ++ ++static PyObject * ++do_share_getattro(PyObject *o, PyObject *n) ++{ ++ assert_share_state((CurlShareObject *)o); ++ PyObject *v = PyObject_GenericGetAttr(o, n); ++ if( !v && PyErr_ExceptionMatches(PyExc_AttributeError) ) ++ { ++ PyErr_Clear(); ++ v = my_getattro(o, n, ((CurlShareObject *)o)->dict, ++ curlshareobject_constants, curlshareobject_methods); ++ } ++ return v; ++} ++ ++static int ++do_share_setattro(PyObject *o, PyObject *n, PyObject *v) ++{ ++ assert_share_state((CurlShareObject *)o); ++ if( v ) ++ { ++ return my_setattro(&((CurlShareObject *)o)->dict, n, v); ++ } else ++ { ++ return PyObject_GenericSetAttr(o, n, 0); ++ } ++} ++ ++#else + static int + my_setattr(PyObject **dict, char *name, PyObject *v) + { +@@ -3026,6 +3305,7 @@ + return Py_FindMethod(m, co, name); + } + ++ + static int + do_share_setattr(CurlShareObject *so, char *name, PyObject *v) + { +@@ -3070,10 +3350,53 @@ + return my_getattr((PyObject *)co, name, co->dict, + curlmultiobject_constants, curlmultiobject_methods); + } ++#endif + + +-/* --------------- actual type definitions --------------- */ + ++/* --------------- actual type definitions --------------- */ ++#if PY_MAJOR_VERSION >= 3 ++static PyTypeObject CurlShare_Type = { ++ PyVarObject_HEAD_INIT(NULL, 0) ++ "pycurl.CurlShare", /* tp_name */ ++ sizeof(CurlShareObject), /* tp_basicsize */ ++ 0, /* tp_itemsize */ ++ (destructor)do_share_dealloc,/* tp_dealloc */ ++ 0, /* tp_print */ ++ 0, /* tp_getattr */ ++ 0, /* tp_setattr */ ++ 0, /* tp_reserved */ ++ 0, /* tp_repr */ ++ 0, /* tp_as_number */ ++ 0, /* tp_as_sequence */ ++ 0, /* tp_as_mapping */ ++ 0, /* tp_hash */ ++ 0, /* tp_call */ ++ 0, /* tp_str */ ++ (getattrofunc)do_share_getattro, /* tp_getattro */ ++ (setattrofunc)do_share_setattro, /* tp_setattro */ ++ 0, /* tp_as_buffer */ ++ Py_TPFLAGS_HAVE_GC, /* tp_flags */ ++ 0, /* tp_doc */ ++ (traverseproc)do_share_traverse, /* tp_traverse */ ++ (inquiry)do_share_clear, /* tp_clear */ ++ 0, /* tp_richcompare */ ++ 0, /* tp_weaklistoffset */ ++ 0, /* tp_iter */ ++ 0, /* tp_iternext */ ++ curlshareobject_methods, /* tp_methods */ ++ 0, /* tp_members */ ++ 0, /* tp_getset */ ++ 0, /* tp_base */ ++ 0, /* tp_dict */ ++ 0, /* tp_descr_get */ ++ 0, /* tp_descr_set */ ++ 0, /* tp_dictoffset */ ++ 0, /* tp_init */ ++ 0, /* tp_alloc */ ++ 0, /* tp_new */ ++}; ++#else + static PyTypeObject CurlShare_Type = { + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +@@ -3104,7 +3427,50 @@ + * safely ignore any compiler warnings about missing initializers. + */ + }; ++#endif + ++#if PY_MAJOR_VERSION >= 3 ++static PyTypeObject Curl_Type = { ++ PyVarObject_HEAD_INIT(NULL, 0) ++ "pycurl.Curl", /* tp_name */ ++ sizeof(CurlObject), /* tp_basicsize */ ++ 0, /* tp_itemsize */ ++ (destructor)do_curl_dealloc,/* tp_dealloc */ ++ 0, /* tp_print */ ++ 0, /* tp_getattr */ ++ 0, /* tp_setattr */ ++ 0, /* tp_reserved */ ++ 0, /* tp_repr */ ++ 0, /* tp_as_number */ ++ 0, /* tp_as_sequence */ ++ 0, /* tp_as_mapping */ ++ 0, /* tp_hash */ ++ 0, /* tp_call */ ++ 0, /* tp_str */ ++ (getattrofunc)do_curl_getattro, /* tp_getattro */ ++ (setattrofunc)do_curl_setattro, /* tp_setattro */ ++ 0, /* tp_as_buffer */ ++ Py_TPFLAGS_HAVE_GC, /* tp_flags */ ++ 0, /* tp_doc */ ++ (traverseproc)do_curl_traverse, /* tp_traverse */ ++ (inquiry)do_curl_clear, /* tp_clear */ ++ 0, /* tp_richcompare */ ++ 0, /* tp_weaklistoffset */ ++ 0, /* tp_iter */ ++ 0, /* tp_iternext */ ++ curlobject_methods, /* tp_methods */ ++ 0, /* tp_members */ ++ 0, /* tp_getset */ ++ 0, /* tp_base */ ++ 0, /* tp_dict */ ++ 0, /* tp_descr_get */ ++ 0, /* tp_descr_set */ ++ 0, /* tp_dictoffset */ ++ 0, /* tp_init */ ++ 0, /* tp_alloc */ ++ 0, /* tp_new */ ++}; ++#else + static PyTypeObject Curl_Type = { + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +@@ -3135,7 +3501,50 @@ + * safely ignore any compiler warnings about missing initializers. + */ + }; ++#endif + ++#if PY_MAJOR_VERSION >= 3 ++static PyTypeObject CurlMulti_Type = { ++ PyVarObject_HEAD_INIT(NULL, 0) ++ "pycurl.CurlMulti", /* tp_name */ ++ sizeof(CurlMultiObject), /* tp_basicsize */ ++ 0, /* tp_itemsize */ ++ (destructor)do_multi_dealloc,/* tp_dealloc */ ++ 0, /* tp_print */ ++ 0, // (getattrfunc)do_curl_getattr, /* tp_getattr */ ++ 0, //(setattrfunc)do_curl_setattr, /* tp_setattr */ ++ 0, /* tp_reserved */ ++ 0, /* tp_repr */ ++ 0, /* tp_as_number */ ++ 0, /* tp_as_sequence */ ++ 0, /* tp_as_mapping */ ++ 0, /* tp_hash */ ++ 0, /* tp_call */ ++ 0, /* tp_str */ ++ (getattrofunc)do_multi_getattro, //0, /* tp_getattro */ ++ (setattrofunc)do_multi_setattro, /* tp_setattro */ ++ 0, /* tp_as_buffer */ ++ Py_TPFLAGS_HAVE_GC, /* tp_flags */ ++ 0, /* tp_doc */ ++ (traverseproc)do_multi_traverse, /* tp_traverse */ ++ (inquiry)do_multi_clear, /* tp_clear */ ++ 0, /* tp_richcompare */ ++ 0, /* tp_weaklistoffset */ ++ 0, /* tp_iter */ ++ 0, /* tp_iternext */ ++ curlmultiobject_methods, /* tp_methods */ ++ 0, /* tp_members */ ++ 0, /* tp_getset */ ++ 0, /* tp_base */ ++ 0, /* tp_dict */ ++ 0, /* tp_descr_get */ ++ 0, /* tp_descr_set */ ++ 0, /* tp_dictoffset */ ++ 0, /* tp_init */ ++ 0, /* tp_alloc */ ++ 0, /* tp_new */ ++}; ++#else + static PyTypeObject CurlMulti_Type = { + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +@@ -3166,7 +3575,7 @@ + * safely ignore any compiler warnings about missing initializers. + */ + }; +- ++#endif + + /************************************************************************* + // module level +@@ -3224,7 +3633,11 @@ + } + while (*s == ' ' || *s == '\t') + s++; ++#if PY_MAJOR_VERSION >= 3 ++ return PyUnicode_FromString(s); ++#else + return PyString_FromString(s); ++#endif + } + + static PyObject * +@@ -3351,7 +3764,13 @@ + goto error; + if (value == NULL) + goto error; ++ ++#if PY_MAJOR_VERSION >= 3 ++ key = PyUnicode_FromString(name); ++#else + key = PyString_FromString(name); ++#endif ++ + if (key == NULL) + goto error; + #if 0 +@@ -3378,7 +3797,11 @@ + static void + insstr(PyObject *d, char *name, char *value) + { ++#if PY_MAJOR_VERSION >= 3 ++ PyObject *v = PyUnicode_FromString(value); ++#else + PyObject *v = PyString_FromString(value); ++#endif + insobj2(d, NULL, name, v); + } + +@@ -3411,6 +3834,20 @@ + } + + ++#if PY_MAJOR_VERSION >= 3 ++static PyModuleDef curlmodule = { ++ PyModuleDef_HEAD_INIT, ++ "pycurl", ++ module_doc, ++ -1, ++ curl_methods, NULL, NULL, NULL, NULL ++}; ++#endif ++ ++ ++#if PY_MAJOR_VERSION >= 3 ++PyMODINIT_FUNC PyInit_pycurl(void) ++#else + /* Initialization function for the module */ + #if defined(PyMODINIT_FUNC) + PyMODINIT_FUNC +@@ -3421,6 +3858,7 @@ + DL_EXPORT(void) + #endif + initpycurl(void) ++#endif + { + PyObject *m, *d; + const curl_version_info_data *vi; +@@ -3430,13 +3868,29 @@ + p_Curl_Type = &Curl_Type; + p_CurlMulti_Type = &CurlMulti_Type; + p_CurlShare_Type = &CurlShare_Type; +- Curl_Type.ob_type = &PyType_Type; +- CurlMulti_Type.ob_type = &PyType_Type; +- CurlShare_Type.ob_type = &PyType_Type; ++ Py_TYPE(&Curl_Type) = &PyType_Type; ++ Py_TYPE(&CurlMulti_Type) = &PyType_Type; ++ Py_TYPE(&CurlShare_Type) = &PyType_Type; + + /* Create the module and add the functions */ ++#if PY_MAJOR_VERSION >= 3 ++ if (PyType_Ready(&Curl_Type) < 0) ++ return NULL; ++ ++ if (PyType_Ready(&CurlMulti_Type) < 0) ++ return NULL; ++ ++ ++ m = PyModule_Create(&curlmodule); ++ if (m == NULL) ++ return NULL; ++ ++ Py_INCREF(&Curl_Type); ++#else ++ + m = Py_InitModule3("pycurl", curl_methods, module_doc); + assert(m != NULL && PyModule_Check(m)); ++#endif + + /* Add error object to the module */ + d = PyModule_GetDict(m); +@@ -3903,6 +4357,9 @@ + /* Finally initialize global interpreter lock */ + PyEval_InitThreads(); + ++#if PY_MAJOR_VERSION >= 3 ++ return m; ++#endif + } + + /* vi:ts=4:et:nowrap diff --git a/python-pycurl.changes b/python-pycurl.changes index 4bc306b..6cbd213 100644 --- a/python-pycurl.changes +++ b/python-pycurl.changes @@ -1,3 +1,9 @@ +------------------------------------------------------------------- +Sat Apr 28 06:42:57 UTC 2012 - highwaystar.ru@gmail.com + +- added python3 package +- spec file slighly cleaned (old buildroot macro replaced) + ------------------------------------------------------------------- Thu Jan 12 11:31:10 UTC 2012 - coolo@suse.com diff --git a/python-pycurl.spec b/python-pycurl.spec index 35da18c..66fa454 100644 --- a/python-pycurl.spec +++ b/python-pycurl.spec @@ -15,6 +15,7 @@ # Please submit bugfixes or comments via http://bugs.opensuse.org/ # + Name: python-pycurl Version: 7.19.0 Release: 0 @@ -57,7 +58,7 @@ CFLAGS="%{optflags}" python setup.py build %install python setup.py install --prefix=%{_prefix} --root=%{buildroot} -rm -rf $RPM_BUILD_ROOT%{_datadir}/doc # Remove wrongly installed junk +rm -rf %{buildroot}%{_datadir}/doc # Remove wrongly installed junk %files %defattr(-,root,root,-) diff --git a/python3-pycurl.changes b/python3-pycurl.changes new file mode 100644 index 0000000..0d11d0d --- /dev/null +++ b/python3-pycurl.changes @@ -0,0 +1,6 @@ +------------------------------------------------------------------- +Sat Apr 28 06:43:11 UTC 2012 - highwaystar.ru@gmail.com + +- python3 package created +- added python3 patch from upstream bugtracker + diff --git a/python3-pycurl.spec b/python3-pycurl.spec new file mode 100644 index 0000000..e38b3e6 --- /dev/null +++ b/python3-pycurl.spec @@ -0,0 +1,78 @@ +# +# spec file for package python3-pycurl +# +# Copyright (c) 2012 SUSE LINUX Products GmbH, Nuernberg, Germany. +# +# All modifications and additions to the file contributed by third parties +# remain the property of their copyright owners, unless otherwise agreed +# upon. The license for this file, and modifications and additions to the +# file, is the same license as for the pristine package itself (unless the +# license for the pristine package is not an Open Source License, in which +# case the license is the MIT License). An "Open Source License" is a +# license that conforms to the Open Source Definition (Version 1.9) +# published by the Open Source Initiative. + +# Please submit bugfixes or comments via http://bugs.opensuse.org/ +# + + +# +%define modname pycurl +Name: python3-%{modname} +Version: 7.19.0 +Release: 0 +Url: http://pycurl.sourceforge.net/ +Summary: PycURL -- cURL library module +License: LGPL-2.1+ and MIT +Group: Development/Languages/Python +Source: %{modname}-%{version}.tar.gz +Patch0: %{modname}-7.18.1-nostaticlibs.patch +#patch from upstream http://sourceforge.net/tracker/?func=detail&aid=3188495&group_id=28236&atid=392779 +Patch1: pycurl-python3.patch +BuildRoot: %{_tmppath}/%{name}-%{version}-build +BuildRequires: libcurl-devel >= 7.19.0 +BuildRequires: openssl-devel +BuildRequires: python3-2to3 +BuildRequires: python3-devel +%if 0%{?suse_version} <= 1140 +%{!?python3_sitearch: %global python3_sitearch %(python3 -c "from distutils.sysconfig import get_python_lib; print(get_python_lib(1))")} +%{!?py3_ver: %global py3_ver %(python3 -c "import sys; version=str(sys.version_info[0]) + '.' + str(sys.version_info[1]); print(version)" 2>/dev/null || echo PYTHON-NOT-FOUND)} +%endif +Requires: python3 >= %{py3_ver} + +%description +This module provides bindings for the cURL library. + +%package doc +Summary: Documentation for python-curl +Group: Development/Libraries/Python +Requires: %{name} = %{version} + +%description doc +This module provides bindings for the cURL library. + +This package contains documentation and examples. + +%prep +%setup -q -n %{modname}-%{version} +%patch0 +%patch1 -p1 + +%build +2to3 -w --no-diffs -n . +CFLAGS="%{optflags}" python3 setup.py build + +%install +python3 setup.py install --prefix=%{_prefix} --root=%{buildroot} +rm -rf %{buildroot}%{_datadir}/doc # Remove wrongly installed junk + +%files +%defattr(-,root,root,-) +%doc ChangeLog COPYING README TODO +%{python3_sitearch}/* + +%files doc +%defattr(-,root,root) +%doc examples doc/*.html + +%changelog