Merge pull request #1 from vinichou94/poursuite_python3

Purcue python3

Author: vincsdev

.gitignore

@@ -4,3 +4,4 @@ build/
 dist/
 pymodbus.egg-info/
 .coverage
+*__pycache__

CHANGELOG.rst

@@ -1,3 +1,8 @@
+Version 1.3.0
+------------------------------------------------------------
+
+* Porting to Python 3
+
 Version 1.2.0
 ------------------------------------------------------------
 

examples/common/asynchronous-client.py

@@ -30,9 +30,10 @@
 # helper method to test deferred callbacks
 #---------------------------------------------------------------------------# 
 def dassert(deferred, callback):
-    def _assertor(value): assert(value)
+    def _assertor(value, message=None):
+        assert value, message
     deferred.addCallback(lambda r: _assertor(callback(r)))
-    deferred.addErrback(lambda  _: _assertor(False))
+    deferred.addErrback(lambda  e: _assertor(False, e))
 
 #---------------------------------------------------------------------------# 
 # specify slave to query

examples/common/callback-server.py

@@ -15,6 +15,7 @@
 from pymodbus.datastore import ModbusSparseDataBlock
 from pymodbus.datastore import ModbusSlaveContext, ModbusServerContext
 from pymodbus.transaction import ModbusRtuFramer, ModbusAsciiFramer
+from pymodbus.compat import iterkeys
 
 #---------------------------------------------------------------------------# 
 # import the python libraries we need
@@ -44,7 +45,7 @@ def __init__(self, devices, queue):
         self.devices = devices
         self.queue = queue
 
-        values = {k:0 for k in devices.iterkeys()}
+        values = {k:0 for k in iterkeys(devices)}
         values[0xbeef] = len(values) # the number of devices
         super(CallbackDataBlock, self).__init__(values)
 

examples/common/changing-framers.py

@@ -39,7 +39,7 @@
 #---------------------------------------------------------------------------# 
 # Initialize the client
 #---------------------------------------------------------------------------# 
-client = ModbusClient('localhost', port=5020, framer=ModbusFramer)
+client = ModbusClient('localhost', port=502, framer=ModbusFramer)
 client.connect()
 
 #---------------------------------------------------------------------------# 

examples/common/custom-message.py

@@ -83,5 +83,5 @@ def __init__(self, address):
 with ModbusClient('127.0.0.1') as client:
     request = CustomModbusRequest(0)
     result  = client.execute(request)
-    print result
+    print(result)
 

examples/common/modbus-payload.py

@@ -7,6 +7,7 @@
 from pymodbus.payload import BinaryPayloadDecoder
 from pymodbus.payload import BinaryPayloadBuilder
 from pymodbus.client.sync import ModbusTcpClient as ModbusClient
+from pymodbus.compat import iteritems
 
 #---------------------------------------------------------------------------# 
 # configure the client logging
@@ -36,7 +37,7 @@
 # - an 8 bit bitstring [0,1,0,1,1,0,1,0]
 #---------------------------------------------------------------------------# 
 builder = BinaryPayloadBuilder(endian=Endian.Little)
-builder.add_string('abcdefgh')
+builder.add_string(b'abcdefgh')
 builder.add_32bit_float(22.34)
 builder.add_16bit_uint(0x1234)
 builder.add_8bit_int(0x12)
@@ -64,17 +65,17 @@
 decoder = BinaryPayloadDecoder.fromRegisters(result.registers, endian=Endian.Little)
 decoded = {
     'string': decoder.decode_string(8),
-    'float': decoder.decode_32bit_float(),
+    'float':  decoder.decode_32bit_float(),
     '16uint': decoder.decode_16bit_uint(),
-    '8int': decoder.decode_8bit_int(),
-    'bits': decoder.decode_bits(),
+    '8int':   decoder.decode_8bit_int(),
+    'bits':   decoder.decode_bits(),
 }
 
-print "-" * 60
-print "Decoded Data"
-print "-" * 60
-for name, value in decoded.iteritems():
-    print ("%s\t" % name), value
+print("-" * 60)
+print("Decoded Data")
+print("-" * 60)
+for name, value in iteritems(decoded):
+    print(("%s\t" % name), value)
 
 #---------------------------------------------------------------------------# 
 # close the client

examples/common/performance.py

@@ -54,7 +54,7 @@ def single_client_test(host, cycles):
 
     try:
         count  = 0
-        client = ModbusTcpClient(host)
+        client = ModbusTcpClient(host, port=5020)
         while count < cycles:
             result = client.read_holding_registers(10, 1).getRegister(0)
             count += 1
@@ -75,4 +75,4 @@ def single_client_test(host, cycles):
 any(p.start() for p in procs)   # start the workers
 any(p.join()  for p in procs)   # wait for the workers to finish
 stop  = time()
-print "%d requests/second" % ((1.0 * cycles) / (stop - start))
+print("%d requests/second" % ((1.0 * cycles) / (stop - start)))

examples/contrib/bcd-payload.py

@@ -6,6 +6,7 @@
 that can be used in the pymodbus library. Below is a 
 simple binary coded decimal builder and decoder.
 '''
+import unittest
 from struct import pack, unpack
 from pymodbus.constants import Endian
 from pymodbus.interfaces import IPayloadBuilder
@@ -23,7 +24,7 @@ def convert_to_bcd(decimal):
     while decimal > 0:
         nibble = decimal % 10
         bcd += nibble << place
-        decimal /= 10
+        decimal //= 10
         place += 4
     return bcd
 
@@ -76,12 +77,12 @@ def __init__(self, payload=None, endian=Endian.Little):
         self._payload = payload or []
         self._endian  = endian
 
-    def __str__(self):
+    def to_string(self):
         ''' Return the payload buffer as a string
 
         :returns: The payload buffer as a string
         '''
-        return ''.join(self._payload)
+        return b''.join(self._payload)
 
     def reset(self):
         ''' Reset the payload buffer
@@ -96,10 +97,10 @@ def build(self):
 
         :returns: The payload buffer as a list
         '''
-        string = str(self)
+        string = self.to_string()
         length = len(string)
-        string = string + ('\x00' * (length % 2))
-        return [string[i:i+2] for i in xrange(0, length, 2)]
+        string = string + (b'\x00' * (length % 2))
+        return [string[i:i+2] for i in range(0, length, 2)]
 
     def add_bits(self, values):
         ''' Adds a collection of bits to be encoded
@@ -217,6 +218,44 @@ def decode_string(self, size=1):
         return self._payload[self._pointer - size:self._pointer]
 
 
+#---------------------------------------------------------------------------#
+# Fixture
+#---------------------------------------------------------------------------#
+class BcdPayloadUtilityTests(unittest.TestCase):
+
+    def setUp(self):
+        '''
+        Initializes the test environment and builds request/result
+        encoding pairs
+        '''
+        self.bitstring = [True, False, False, False, True, False, False, False]
+        self.payload = \
+            b'\x01\x02\x00\x03\x00\x00\x00\x04\x00\x00\x00\x00' \
+            b'\x00\x00\x00\xff\xfe\xff\xfd\xff\xff\xff\xfc\xff' \
+            b'\xff\xff\xff\xff\xff\xff\x00\x00\xa0\x3f\x00\x00' \
+            b'\x00\x00\x00\x00\x19\x40\x74\x65\x73\x74\x11'
+
+    def testPayloadBuilder(self):
+        ''' Test basic bit message encoding/decoding '''
+        builder = BcdPayloadBuilder(endian=Endian.Little)
+        builder.add_number(1)
+        builder.add_string(b'test')
+        builder.add_bits(self.bitstring)
+        self.assertEqual(self.payload, builder.to_string())
+
+    def testPayloadDecoder(self):
+        ''' Test basic bit message encoding/decoding '''
+        decoder = BcdPayloadDecoder(self.payload)
+        self.assertEqual(1, decoder.decode_int())
+        self.assertEqual(b'test', decoder.decode_string(4))
+        self.assertEqual(self.bitstring, decoder.decode_bits())
+
+#---------------------------------------------------------------------------#
+# unit tests
+#---------------------------------------------------------------------------#
+if __name__ == "__main__":
+    unittest.main()
+
 #---------------------------------------------------------------------------#
 # Exported Identifiers
 #---------------------------------------------------------------------------#

examples/contrib/message-generator.py

@@ -6,11 +6,13 @@
 The following is an example of how to generate example encoded messages
 for the supplied modbus format:
 
-* tcp    - `./generate-messages.py -f tcp -m rx -b`
-* ascii  - `./generate-messages.py -f ascii -m tx -a`
-* rtu    - `./generate-messages.py -f rtu -m rx -b`
-* binary - `./generate-messages.py -f binary -m tx -b`
+* tcp    - `./message-generator.py -f tcp -m rx -b`
+* ascii  - `./message-generator.py -f ascii -m tx -a`
+* rtu    - `./message-generator.py -f rtu -m rx -b`
+* binary - `./message-generator.py -f binary -m tx -b`
 '''
+from __future__ import print_function
+import binascii
 from optparse import OptionParser
 #--------------------------------------------------------------------------#
 # import all the available framers
@@ -165,11 +167,12 @@ def generate_messages(framer, options):
     messages = _request_messages if options.messages == 'tx' else _response_messages
     for message in messages:
         message = message(**_arguments)
-        print "%-44s = " % message.__class__.__name__,
+        print("%-44s = " % message.__class__.__name__, end = '')
         packet = framer.buildPacket(message)
         if not options.ascii:
-            packet = packet.encode('hex') + '\n'
-        print packet,   # because ascii ends with a \r\n
+            packet = binascii.b2a_hex(packet).decode('utf8') + '\n'
+        else: packet = packet.decode()
+        print(packet, end='')   # because ascii ends with a \r\n
 
 
 #---------------------------------------------------------------------------# 
@@ -213,9 +216,9 @@ def main():
     if option.debug:
         try:
             modbus_log.setLevel(logging.DEBUG)
-    	    logging.basicConfig()
-        except Exception, e:
-    	    print "Logging is not supported on this system"
+            logging.basicConfig()
+        except Exception as e:
+    	    print("Logging is not supported on this system")
 
     framer = lookup = {
         'tcp':    ModbusSocketFramer,