Merge pull request #2 from vinichou94/revert-1-poursuite_python3

Porting to Python3

Author: vincsdev

.gitignore

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

CHANGELOG.rst

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

examples/common/asynchronous-client.py

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

examples/common/callback-server.py

@@ -15,7 +15,6 @@
 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
@@ -45,7 +44,7 @@ def __init__(self, devices, queue):
         self.devices = devices
         self.queue = queue
 
-        values = {k:0 for k in iterkeys(devices)}
+        values = {k:0 for k in devices.iterkeys()}
         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=502, framer=ModbusFramer)
+client = ModbusClient('localhost', port=5020, 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,7 +7,6 @@
 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
@@ -37,7 +36,7 @@
 # - an 8 bit bitstring [0,1,0,1,1,0,1,0]
 #---------------------------------------------------------------------------# 
 builder = BinaryPayloadBuilder(endian=Endian.Little)
-builder.add_string(b'abcdefgh')
+builder.add_string('abcdefgh')
 builder.add_32bit_float(22.34)
 builder.add_16bit_uint(0x1234)
 builder.add_8bit_int(0x12)
@@ -65,17 +64,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 iteritems(decoded):
-    print(("%s\t" % name), value)
+print "-" * 60
+print "Decoded Data"
+print "-" * 60
+for name, value in decoded.iteritems():
+    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, port=5020)
+        client = ModbusTcpClient(host)
         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,7 +6,6 @@
 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
@@ -24,7 +23,7 @@ def convert_to_bcd(decimal):
     while decimal > 0:
         nibble = decimal % 10
         bcd += nibble << place
-        decimal //= 10
+        decimal /= 10
         place += 4
     return bcd
 
@@ -77,12 +76,12 @@ def __init__(self, payload=None, endian=Endian.Little):
         self._payload = payload or []
         self._endian  = endian
 
-    def to_string(self):
+    def __str__(self):
         ''' Return the payload buffer as a string
 
         :returns: The payload buffer as a string
         '''
-        return b''.join(self._payload)
+        return ''.join(self._payload)
 
     def reset(self):
         ''' Reset the payload buffer
@@ -97,10 +96,10 @@ def build(self):
 
         :returns: The payload buffer as a list
         '''
-        string = self.to_string()
+        string = str(self)
         length = len(string)
-        string = string + (b'\x00' * (length % 2))
-        return [string[i:i+2] for i in range(0, length, 2)]
+        string = string + ('\x00' * (length % 2))
+        return [string[i:i+2] for i in xrange(0, length, 2)]
 
     def add_bits(self, values):
         ''' Adds a collection of bits to be encoded
@@ -218,44 +217,6 @@ 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,13 +6,11 @@
 The following is an example of how to generate example encoded messages
 for the supplied modbus format:
 
-* 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`
+* 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`
 '''
-from __future__ import print_function
-import binascii
 from optparse import OptionParser
 #--------------------------------------------------------------------------#
 # import all the available framers
@@ -167,12 +165,11 @@ 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__, end = '')
+        print "%-44s = " % message.__class__.__name__,
         packet = framer.buildPacket(message)
         if not options.ascii:
-            packet = binascii.b2a_hex(packet).decode('utf8') + '\n'
-        else: packet = packet.decode()
-        print(packet, end='')   # because ascii ends with a \r\n
+            packet = packet.encode('hex') + '\n'
+        print packet,   # because ascii ends with a \r\n
 
 
 #---------------------------------------------------------------------------# 
@@ -216,9 +213,9 @@ def main():
     if option.debug:
         try:
             modbus_log.setLevel(logging.DEBUG)
-            logging.basicConfig()
-        except Exception as e:
-    	    print("Logging is not supported on this system")
+    	    logging.basicConfig()
+        except Exception, e:
+    	    print "Logging is not supported on this system"
 
     framer = lookup = {
         'tcp':    ModbusSocketFramer,