Ticket #5158: 5158.2.diff

twisted/python/dist.py

@@ -6 +6 @@
 Maintainer: Christopher Armstrong
 """
 
-import sys, os
 from distutils.command import build_scripts, install_data, build_ext, build_py
 from distutils.errors import CompileError
 from distutils import core
 from distutils.core import Extension
+import fnmatch
+import os
+import platform
+import sys
+
 
 twisted_subprojects = ["conch", "lore", "mail", "names",
                        "news", "pair", "runner", "web",
                        "words"]
 
 
+
 class ConditionalExtension(Extension):
     """
     An extension module that will only be compiled if certain conditions are
@@ -46 +51 @@
     """
     return core.setup(**get_setup_args(**kw))
 
+
 def get_setup_args(**kw):
     if 'twisted_subproject' in kw:
         if 'twisted' not in os.listdir('.'):
@@ -100 +106 @@
         kw.setdefault('cmdclass', {})['build_ext'] = my_build_ext
     return kw
 
+
 def getVersion(proj, base="twisted"):
     """
     Extract the version number for a given project.
@@ -125 +132 @@
                  "RCS", "SCCS", ".svn"]
 EXCLUDE_PATTERNS = ["*.py[cdo]", "*.s[ol]", ".#*", "*~", "*.py"]
 
-import fnmatch
 
 def _filterNames(names):
-    """Given a list of file names, return those names that should be copied.
+    """
+    Given a list of file names, return those names that should be copied.
     """
     names = [n for n in names
              if n not in EXCLUDE_NAMES]
@@ -140 +147 @@
                  and (not n.endswith('.py'))]
     return names
 
+
 def relativeTo(base, relativee):
     """
     Gets 'relativee' relative to 'basepath'.
@@ -201 +209 @@
                             for filename in resultfiles]))
     return result
 
+
 def getPackages(dname, pkgname=None, results=None, ignore=None, parent=None):
     """
     Get all packages which are under dname. This is necessary for
@@ -231 +240 @@
     return res
 
 
-
 def getScripts(projname, basedir=''):
     """
     Returns a list of scripts for a Twisted subproject; this works in
@@ -360 +368 @@
         self.compiler.announce("checking for %s ..." % header_name, 0)
         return self._compile_helper("#include <%s>\n" % header_name)
 
+
+
+def _checkCPython(sys=sys, platform=platform):
+    """
+    Checks if this implementation is CPython.
+
+    On recent versions of Python, will use L{platform.python_implementation}.
+    On 2.5, it will try to extract the implementation from sys.subversion. On
+    older versions (currently the only supported older version is 2.4), checks
+    if C{__pypy__} is in L{sys.modules}, since PyPy is the implementation we
+    really care about. If it isn't, assumes CPython.
+
+    This takes C{sys} and C{platform} kwargs that by default use the real
+    modules. You shouldn't care about these -- they are for testing purposes
+    only.
+
+    @return: C{False} if the implementation is definitely not CPython, C{True}
+        otherwise.
+    """
+    try:
+        return platform.python_implementation() == "CPython"
+    except AttributeError:
+        # For 2.5:
+        try:
+            implementation, _, _ = sys.subversion
+            return implementation == "CPython"
+        except AttributeError:
+            pass
+
+        # Are we on Pypy?
+        if "__pypy__" in sys.modules:
+            return False
+
+        # No? Well, then we're *probably* on CPython.
+        return True
+
+
+_isCPython = _checkCPython()
+
+
+def _hasEpoll(builder):
+    """
+    Checks if the header for building epoll (C{sys/epoll.h}) is available.
+
+    @return: C{True} if the header is available, C{False} otherwise.
+    """
+    return builder._check_header("sys/epoll.h")

twisted/python/test/test_dist.py

@@ -190 +190 @@
         os.mkdir(basedir)
         scripts = dist.getScripts('noscripts', basedir=basedir)
         self.assertEqual(scripts, [])
+
+
+
+class FakeModule(object):
+    """
+    A fake module, suitable for dependency injection in testing.
+    """
+    def __init__(self, attrs):
+        """
+        Initializes a fake module.
+
+        @param attrs: The attrs that will be accessible on the module.
+        @type attrs: C{dict} of C{str} (Python names) to objects
+        """
+        self._attrs = attrs
+
+    def __getattr__(self, name):
+        """
+        Gets an attribute of this fake module from its attrs.
+
+        @raise AttributeError: When the requested attribute is missing.
+        """
+        try:
+            return self._attrs[name]
+        except KeyError:
+            raise AttributeError()
+
+
+
+fakeCPythonPlatform = FakeModule({"python_implementation": lambda: "CPython"})
+fakeOtherPlatform = FakeModule({"python_implementation": lambda: "lvhpy"})
+emptyPlatform = FakeModule({})
+
+
+
+class WithPlatformTest(TestCase):
+    """
+    Tests if L{_checkCPython} works correctly with (fake) recent
+    C{platform} modules.
+    """
+    def test_cpython(self):
+        """
+        Tests that L{_checkCPython} returns C{True} when
+        C{platform.python_implementation} says we're running on CPython.
+        """
+        self.assertTrue(dist._checkCPython(platform=fakeCPythonPlatform))
+
+
+    def test_other(self):
+        """
+        Tests that L{_checkCPython} returns C{True} when
+        C{platform.python_implementation} says we're not running on CPython.
+        """
+        self.assertFalse(dist._checkCPython(platform=fakeOtherPlatform))
+
+
+
+fakeCPythonSys = FakeModule({"subversion": ("CPython", None, None)})
+fakeOtherSys = FakeModule({"subversion": ("lvhpy", None, None)})
+
+
+def _checkCPythonWithEmptyPlatform(sys):
+    """
+    A partially applied L{_checkCPython} that uses an empty C{platform}
+    module (otherwise the code this test case is supposed to test won't
+    even be called).
+    """
+    return dist._checkCPython(platform=emptyPlatform, sys=sys)
+
+
+
+class WithSubversionTest(TestCase):
+    """
+    Tests if L{_checkCPython} works correctly with (fake) recent (2.5+)
+    C{sys.subversion}. This is effectively only relevant for 2.5, since 2.6
+    and beyond have L{platform.python_implementation}, which is tried first.
+    """
+    def test_cpython(self):
+        """
+        Tests that L{_checkCPython} returns C{True} when
+        C{platform.python_implementation} is unavailable and C{sys.subversion}
+        says we're running on CPython.
+        """
+        isCPython = _checkCPythonWithEmptyPlatform(fakeCPythonSys)
+        self.assertTrue(isCPython)
+
+
+    def test_other(self):
+        """
+        Tests that L{_checkCPython} returns C{False} when
+        C{platform.python_implementation} is unavailable and C{sys.subversion}
+        says we're not running on CPython.
+        """
+        isCPython = _checkCPythonWithEmptyPlatform(fakeOtherSys)
+        self.assertFalse(isCPython)
+
+
+
+oldCPythonSys = FakeModule({"modules": {}})
+oldPypySys = FakeModule({"modules": {"__pypy__": None}})
+
+
+class OldPythonsFallbackTest(TestCase):
+    """
+    Tests if L{_checkCPython} correctly recognizes PyPy on 2.4, when neither
+    C{platform.python_implementation} or C{sys.subversion} is available.
+    """
+    def test_cpython(self):
+        """
+        Tests that L{_checkCPython} returns C{True} when both
+        C{platform.python_implementation} and C{sys.subversion} are
+        unavailable and there is no C{__pypy__} module in C{sys.modules}.
+        """
+        isCPython = _checkCPythonWithEmptyPlatform(oldCPythonSys)
+        self.assertTrue(isCPython)
+
+
+    def test_pypy(self):
+        """
+        Tests that L{_checkCPython} returns C{False} when both
+        C{platform.python_implementation} and C{sys.subversion} are
+        unavailable and there is a C{__pypy__} module in C{sys.modules}.
+        """
+        isCPython = _checkCPythonWithEmptyPlatform(oldPypySys)
+        self.assertFalse(isCPython)

twisted/topfiles/setup.py

@@ -6 +6 @@
 Distutils installer for Twisted.
 """
 
-import os, sys
+import os
+import sys
 
 if sys.version_info < (2,3):
     print >>sys.stderr, "You must use at least Python 2.3 for Twisted"
@@ -17 +18 @@
 from twisted import copyright
 from twisted.python.dist import setup, ConditionalExtension as Extension
 from twisted.python.dist import getPackages, getDataFiles, getScripts
-from twisted.python.dist import twisted_subprojects
-
+from twisted.python.dist import twisted_subprojects, _isCPython, _hasEpoll
 
 
 extensions = [
     Extension("twisted.test.raiser",
-              ["twisted/test/raiser.c"]),
+              ["twisted/test/raiser.c"],
+              condition=lambda _: _isCPython),
 
     Extension("twisted.python._epoll",
               ["twisted/python/_epoll.c"],
-              condition=lambda builder: builder._check_header("sys/epoll.h")),
+              condition=lambda builder: _isCPython and _hasEpoll(builder)),
 
     Extension("twisted.internet.iocpreactor.iocpsupport",
               ["twisted/internet/iocpreactor/iocpsupport/iocpsupport.c",
                "twisted/internet/iocpreactor/iocpsupport/winsock_pointers.c"],
               libraries=["ws2_32"],
-              condition=lambda builder: sys.platform == "win32"),
+              condition=lambda _: _isCPython and sys.platform == "win32"),
 
     Extension("twisted.python._initgroups",
               ["twisted/python/_initgroups.c"]),
     Extension("twisted.internet._sigchld",
               ["twisted/internet/_sigchld.c"],
-              condition=lambda builder: sys.platform != "win32"),
+              condition=lambda _: sys.platform != "win32"),
 ]
 
 # Figure out which plugins to include: all plugins except subproject ones