Merge pull request asottile-archive#2 from asottile/support_imports

Support imports

Author: asottile

setuptools_golang.py

@@ -1,18 +1,25 @@
 from __future__ import print_function
 from __future__ import unicode_literals
 
+import contextlib
 import distutils.sysconfig
 import os
 import pipes
+import shutil
 import subprocess
 import sys
+import tempfile
 
 from setuptools.command.build_ext import build_ext as _build_ext
 
 
 PYPY = '__pypy__' in sys.builtin_module_names
 
 
+def _get_cflags(compiler):
+    return ' '.join('-I{}'.format(p) for p in compiler.include_dirs)
+
+
 def _get_ldflags_pypy():
     if PYPY:  # pragma: no cover (pypy only)
         return '-L{} -lpypy-c'.format(
@@ -60,6 +67,15 @@ def _print_cmd(env, cmd):
     )
 
 
+@contextlib.contextmanager
+def _tmpdir():
+    tempdir = tempfile.mkdtemp()
+    try:
+        yield tempdir
+    finally:
+        shutil.rmtree(tempdir)
+
+
 class build_ext(_build_ext):
     def build_extension(self, ext):
         # If there are no .go files then the parent should handle this
@@ -88,20 +104,32 @@ def build_extension(self, ext):
         source_dir, = source_dirs
         source_dir = os.path.abspath(source_dir)
 
-        env = {
-            'CGO_CFLAGS': ' '.join(
-                '-I{}'.format(p) for p in self.compiler.include_dirs
-            ),
-            'CGO_LDFLAGS': _get_ldflags(),
-        }
-        cmd = (
-            'go', 'build', '-buildmode=c-shared',
-            '-o', os.path.abspath(self.get_ext_fullpath(ext.name)),
-        )
-        _print_cmd(env, cmd)
-        subprocess.check_call(
-            cmd, cwd=source_dir, env=dict(os.environ, **env),
-        )
+        # Copy the package into a temporary GOPATH environment
+        with _tmpdir() as tempdir:
+            srcdir = os.path.join(tempdir, 'src')
+            os.mkdir(srcdir)
+            pkg_path = os.path.join(srcdir, '_mypkg')
+            shutil.copytree(source_dir, pkg_path)
+
+            env = {
+                'GOPATH': tempdir,
+                'CGO_CFLAGS': _get_cflags(self.compiler),
+                'CGO_LDFLAGS': _get_ldflags(),
+            }
+            cmd_get = ('go', 'get')
+            _print_cmd(env, cmd_get)
+            subprocess.check_call(
+                cmd_get, cwd=pkg_path, env=dict(os.environ, **env),
+            )
+
+            cmd_build = (
+                'go', 'build', '-buildmode=c-shared',
+                '-o', os.path.abspath(self.get_ext_fullpath(ext.name)),
+            )
+            _print_cmd(env, cmd_build)
+            subprocess.check_call(
+                cmd_build, cwd=pkg_path, env=dict(os.environ, **env),
+            )
 
 
 def set_build_ext(dist, attr, value):

setuptools_golang_test.py

@@ -128,6 +128,15 @@ def test_integration_project_with_c(venv):
     assert out == 'hello world\n'
 
 
+RED = 'import red; print(red.red(u"ohai"))'
+
+
+def test_integration_imports_gh(venv):
+    run(venv.pip, 'install', 'testing/imports_gh')
+    out = run_output(venv.python, '-c', RED)
+    assert out == '\x1b[31mohai\x1b[0m\n'
+
+
 def test_integration_notfound(venv):
     ret = run(
         venv.pip, 'install', 'testing/notfound',

testing/imports_gh/red.c

@@ -0,0 +1,47 @@
+#include <Python.h>
+
+#if PY_MAJOR_VERSION >= 3
+#define PyRed_Bytes_AS_STRING PyBytes_AS_STRING
+#else
+#define PyRed_Bytes_AS_STRING PyString_AS_STRING
+#endif
+
+/* Will come from go */
+PyObject* red(PyObject*);
+
+/* To shim go's missing variadic function support */
+int PyArg_ParseTuple_U(PyObject* args, PyObject** obj) {
+    return PyArg_ParseTuple(args, "U", obj);
+}
+
+/* To shim go's lack of C macro support */
+void PyRed_DECREF(PyObject* obj) {
+    Py_DECREF(obj);
+}
+
+const char* PyRed_Bytes_AsString(PyObject* s) {
+    return PyRed_Bytes_AS_STRING(s);
+}
+
+static struct PyMethodDef methods[] = {
+    {"red", (PyCFunction)red, METH_VARARGS},
+    {NULL, NULL}
+};
+
+#if PY_MAJOR_VERSION >= 3
+static struct PyModuleDef module = {
+    PyModuleDef_HEAD_INIT,
+    "red",
+    NULL,
+    -1,
+    methods
+};
+
+PyMODINIT_FUNC PyInit_red(void) {
+    return PyModule_Create(&module);
+}
+#else
+PyMODINIT_FUNC initred(void) {
+    Py_InitModule3("red", methods, NULL);
+}
+#endif

testing/imports_gh/red.go

@@ -0,0 +1,30 @@
+package main
+
+// #include <stdlib.h>
+// #include <Python.h>
+// int PyArg_ParseTuple_U(PyObject*, PyObject**);
+// const char* PyRed_Bytes_AsString(PyObject*);
+// void PyRed_DECREF(PyObject*);
+import "C"
+import "unsafe"
+import "github.com/mgutz/ansi"
+
+//export red
+func red(self *C.PyObject, args *C.PyObject) *C.PyObject {
+	var obj *C.PyObject
+	if C.PyArg_ParseTuple_U(args, &obj) == 0 {
+		return nil
+	}
+	bytes := C.PyUnicode_AsUTF8String(obj)
+	cstr := C.PyRed_Bytes_AsString(bytes)
+	red := ansi.Color(C.GoString(cstr), "red")
+	cstr = C.CString(red)
+	ret := C.PyUnicode_FromString(cstr)
+
+	C.free(unsafe.Pointer(cstr))
+	C.PyRed_DECREF(bytes)
+
+	return ret
+}
+
+func main() {}

testing/imports_gh/setup.py

@@ -0,0 +1,13 @@
+from setuptools import Extension
+from setuptools import setup
+
+
+setup(
+    name='imports-gh',
+    ext_modules=[Extension('red', ['red.go'])],
+    build_golang=True,
+    # Would do this, but we're testing *our* implementation and this would
+    # install from pypi.  We can rely on setuptools-golang being already
+    # installed under test.
+    # setup_requires=['setuptools-golang'],
+)