Merge pull request #59 from DiamondLightSource/remove-sys-version

Remove all references to sys.version_info and associated fixups

Author: Araneidae

src/cothread/catools.py

@@ -83,12 +83,6 @@ def _check_env(name, default):
 CA_ACTION_STACK         = _check_env('CATOOLS_ACTION_STACK', 0)
 
 
-if sys.version_info < (3,):
-    pv_string_types = (str, unicode)
-else:
-    pv_string_types = str
-
-
 class ca_nothing(Exception):
     '''This value is returned as a success or failure indicator from caput,
     as a failure indicator from caget, and may be raised as an exception to
@@ -567,7 +561,7 @@ def camonitor(pvs, callback, **kargs):
         if notify_disconnect is False, and that if the PV subsequently connects
         it will update as normal.
     '''
-    if isinstance(pvs, pv_string_types):
+    if isinstance(pvs, str):
         return _Subscription(pvs, callback, **kargs)
     else:
         return [
@@ -754,7 +748,7 @@ def caget(pvs, **kargs):
     The format of values returned depends on the number of values requested
     for each PV.  If only one value is requested then the value is returned
     as a scalar, otherwise as a numpy array.'''
-    if isinstance(pvs, pv_string_types):
+    if isinstance(pvs, str):
         return caget_one(pvs, **kargs)
     else:
         return caget_array(pvs, **kargs)
@@ -827,7 +821,7 @@ def caput_one(pv, value, datatype=None, wait=False, timeout=5, callback=None):
 
 def caput_array(pvs, values, repeat_value=False, **kargs):
     # Bring the arrays of pvs and values into alignment.
-    if repeat_value or isinstance(values, pv_string_types):
+    if repeat_value or isinstance(values, str):
         # If repeat_value is requested or the value is a string then we treat
         # it as a single value.
         values = [values] * len(pvs)
@@ -898,7 +892,7 @@ def caput(pvs, values, **kargs):
     If caput completed succesfully then .ok is True and .name is the
     corresponding PV name.  If throw=False was specified and a put failed
     then .errorcode is set to the appropriate ECA_ error code.'''
-    if isinstance(pvs, pv_string_types):
+    if isinstance(pvs, str):
         return caput_one(pvs, values, **kargs)
     else:
         return caput_array(pvs, values, **kargs)
@@ -1003,7 +997,7 @@ def connect(pvs, **kargs):
         connected to.  If this is set to False then instead for each failing
         PV a sentinel value with .ok == False is returned.
     '''
-    if isinstance(pvs, pv_string_types):
+    if isinstance(pvs, str):
         return connect_one(pvs, **kargs)
     else:
         return connect_array(pvs, **kargs)

src/cothread/coserver.py

@@ -24,14 +24,8 @@
 
 import sys
 
-if sys.version_info < (3,):
-    from SocketServer import BaseServer, TCPServer, UDPServer, ThreadingMixIn
-    from BaseHTTPServer import HTTPServer, test as _test
-    from SimpleHTTPServer import SimpleHTTPRequestHandler
-
-else:
-    from socketserver import BaseServer, TCPServer, UDPServer, ThreadingMixIn
-    from http.server import HTTPServer, SimpleHTTPRequestHandler, test as _test
+from socketserver import BaseServer, TCPServer, UDPServer, ThreadingMixIn
+from http.server import HTTPServer, SimpleHTTPRequestHandler, test as _test
 
 from . import cothread
 from . import cosocket

src/cothread/cosocket.py

@@ -186,32 +186,17 @@ def sendall(self, data, *flags):
     def dup(self):
         return cosocket(_sock=self.__socket.dup())
 
-    if sys.version_info < (3,):
-        @wrap
-        def makefile(self, *args, **kws):
-            # At this point the actual socket '_socket.socket' is wrapped by
-            # either two layers: 'socket.socket' and this class.  or a single
-            # layer: this class.  In order to handle close() properly we must
-            # copy all wrappers, but not the underlying actual socket.
-            sock = getattr(self.__socket, '_sock', None)
-            if sock: # double wrapped
-                copy0 = _socket_socket(None, None, None, sock)
-                copy1 = cosocket(None, None, None, copy0)
-            else: # single wrapped
-                copy1 = cosocket(None, None, None, self.__socket)
-            return _socket._fileobject(copy1, *args, **kws)
-    else:
-        @property
-        def _io_refs(self):
-            return self.__socket._io_refs
-
-        @_io_refs.setter
-        def _io_refs(self, value):
-            self.__socket._io_refs = value
-
-        # Can use the original makefile just so long as we provide the _io_refs
-        # property above.
-        makefile = _socket_socket.makefile
+    @property
+    def _io_refs(self):
+        return self.__socket._io_refs
+
+    @_io_refs.setter
+    def _io_refs(self, value):
+        self.__socket._io_refs = value
+
+    # Can use the original makefile just so long as we provide the _io_refs
+    # property above.
+    makefile = _socket_socket.makefile
 
 
 del wrap

src/cothread/cothread.py

@@ -73,6 +73,7 @@
 import traceback
 import collections
 import threading
+import _thread
 
 from . import _coroutine
 
@@ -81,11 +82,6 @@
 
 from . import coselect
 
-if sys.version_info >= (3,):
-    import _thread
-else:
-    import thread as _thread
-
 
 __all__ = [
     'Spawn',            # Spawn new task

src/cothread/dbr.py

@@ -51,7 +51,6 @@
     'DBR_DOUBLE',       # 64 bit float
 
     'DBR_CHAR_STR',     # Long strings as char arrays
-    'DBR_CHAR_UNICODE', # Long unicode strings as char arrays
     'DBR_ENUM_STR',     # Enums as strings, default otherwise
     'DBR_CHAR_BYTES',   # Long byte strings as char arrays
 
@@ -163,29 +162,11 @@ class ca_str(str):
     def __pos__(self):
         return str(self)
 
-
-# Overlapping handling for python 2 and python 3.  We have three types with two
-# different semantics: str, bytes, unicode.  In python2 str is bytes, while in
-# python3 str is unicode.  We walk a delicate balancing act to get the right
-# behaviour in both environments!
-if sys.version_info < (3,):
-    ca_bytes = ca_str
-    class ca_unicode(bytes):
-        __doc__ = ca_doc_string
-        datetime = timestamp_to_datetime
-        def __pos__(self):
-            return unicode(self)
-    str_char_code = 'S'
-else:
-    class ca_bytes(bytes):
-        __doc__ = ca_doc_string
-        datetime = timestamp_to_datetime
-        def __pos__(self):
-            return bytes(self)
-    ca_unicode = ca_str
-    str_char_code = 'U'
-    unicode = str
-
+class ca_bytes(bytes):
+    __doc__ = ca_doc_string
+    datetime = timestamp_to_datetime
+    def __pos__(self):
+        return bytes(self)
 
 class ca_int(int):
     __doc__ = ca_doc_string
@@ -544,7 +525,6 @@ def copy_attributes(self, other):
 # Special value for DBR_CHAR as str special processing.
 DBR_ENUM_STR = 996
 DBR_CHAR_BYTES = 997
-DBR_CHAR_UNICODE = 998
 DBR_CHAR_STR = 999
 
 
@@ -604,7 +584,7 @@ def copy_attributes(self, other):
     'I':    DBR_LONG,       # uintc  = uint32
 
     # Unicode is supported by decoding from DBR_STRING
-    'U':    DBR_STRING,     # str => unicode
+    'U':    DBR_STRING,     # str
 
     # We translate machine native integers to DBR_LONG as EPICS has no support
     # for 64-bit integers, but not allowing int as an argument is too confusing.
@@ -652,7 +632,7 @@ def _type_to_dbrcode(datatype, format):
       - FORMAT_CTRL: retrieve limit and control data
     '''
     if datatype not in BasicDbrTypes:
-        if datatype in [DBR_CHAR_STR, DBR_CHAR_BYTES, DBR_CHAR_UNICODE]:
+        if datatype in [DBR_CHAR_STR, DBR_CHAR_BYTES]:
             datatype = DBR_CHAR     # Retrieve this type using char array
         elif datatype in [DBR_STSACK_STRING, DBR_CLASS_NAME]:
             return (datatype, datatype) # format is meaningless in this case
@@ -713,31 +693,20 @@ def _convert_char_str(raw_dbr, count):
 def _convert_char_bytes(raw_dbr, count):
     return ca_bytes(_string_at(raw_dbr.raw_value, count))
 
-# Conversion from char array to unicode strings
-def _convert_char_unicode(raw_dbr, count):
-    return ca_unicode(_string_at(raw_dbr.raw_value, count).decode('UTF-8'))
-
 
 # Arrays of standard strings.
 def _convert_str_str(raw_dbr, count):
     return ca_str(decode(_make_strings(raw_dbr, count)[0]))
 def _convert_str_str_array(raw_dbr, count):
     strings = [decode(s) for s in _make_strings(raw_dbr, count)]
-    return _string_array(strings, count, str_char_code)
+    return _string_array(strings, count, 'U')
 
 # Arrays of bytes strings.
 def _convert_str_bytes(raw_dbr, count):
     return ca_bytes(_make_strings(raw_dbr, count)[0])
 def _convert_str_bytes_array(raw_dbr, count):
     return _string_array(_make_strings(raw_dbr, count), count, 'S')
 
-# Arrays of unicode strings.
-def _convert_str_unicode(raw_dbr, count):
-    return ca_str(_make_strings(raw_dbr, count)[0].decode('UTF-8'))
-def _convert_str_unicode_array(raw_dbr, count):
-    strings = [s.decode('UTF-8') for s in _make_strings(raw_dbr, count)]
-    return _string_array(strings, count, 'U')
-
 
 # For everything that isn't a string we either return a scalar or a ca_array
 def _convert_other(raw_dbr, count):
@@ -790,16 +759,11 @@ def type_to_dbr(channel, datatype, format):
     elif dtype is numpy.uint8 and datatype == DBR_CHAR_BYTES:
         # Conversion from char array to bytes strings
         convert = _convert_char_bytes
-    elif dtype is numpy.uint8 and datatype == DBR_CHAR_UNICODE:
-        # Conversion from char array to unicode strings
-        convert = _convert_char_unicode
     else:
         if dtype is str_dtype:
-            # String arrays, either unicode or normal.
+            # String arrays
             if isinstance(datatype, type) and issubclass(datatype, bytes):
                 convert = (_convert_str_bytes, _convert_str_bytes_array)
-            elif isinstance(datatype, type) and issubclass(datatype, unicode):
-                convert = (_convert_str_unicode, _convert_str_unicode_array)
             else:
                 convert = (_convert_str_str, _convert_str_str_array)
         else:
@@ -867,7 +831,7 @@ def value_to_dbr(channel, datatype, value):
 
     # If no datatype specified then use the target datatype.
     if datatype is None:
-        if isinstance(value, (str, bytes, unicode)):
+        if isinstance(value, (str, bytes)):
             # Give strings with no datatype special treatment, let the IOC do
             # the decoding.  It's safer this way.
             datatype = DBR_STRING
@@ -893,7 +857,7 @@ def value_to_dbr(channel, datatype, value):
                 # We'll let numpy do most of the heavy lifting.
                 result = _require_value(value, str_dtype)
             except UnicodeEncodeError:
-                # Whoops, looks like unicode, need to encode each string.
+                # Whoops, looks like we need to encode each string.
                 value = _require_value(value, None)
                 result = numpy.empty(value.shape, str_dtype)
                 for n, s in enumerate(value):