only import lib when required

gijzelaerr · gijzelaerr · commit 53295fa3030e · 2013-11-09T16:20:52.000+01:00
diff --git a/run_tests.py b/run_tests.py
@@ -0,0 +1,8 @@
+#!/bin/sh
+
+export PYTHONPATH=.
+sudo nosetests test/test_partner.py
+sudo nosetests test/test_server.py
+sudo PYTHONPATH=. snap7/bin/snap7-server.py &
+nosetests test/test_client.py
+
diff --git a/snap7/bin/snap7-server.py b/snap7/bin/snap7-server.py
@@ -20,7 +20,7 @@ def mainloop():
         while True:
             event = server.pick_event()
             if event:
-                logger.info(snap7.server.event_text(event))
+                logger.info(server.event_text(event))
             else:
                 break
         time.sleep(1)
diff --git a/snap7/client.py b/snap7/client.py
@@ -10,7 +10,6 @@
 from snap7.common import check_error, load_library
 
 logger = logging.getLogger(__name__)
-clib = load_library()
 
 
 def error_wrap(func):
@@ -44,24 +43,25 @@ def __init__(self):
 
         :returns: A Snap7Client object
         """
+        self.library = load_library()
         logger.info("creating snap7 client")
-        self.pointer = S7Object(clib.Cli_Create())
+        self.pointer = S7Object(self.library.Cli_Create())
         # local buffer used by test for now..
 
     def destroy(self):
         """
         destroy a client.
         """
         logger.info("destroying snap7 client")
-        return clib.Cli_Destroy(byref(self.pointer))
+        return self.library.Cli_Destroy(byref(self.pointer))
 
     @error_wrap
     def disconnect(self):
         """
         disconnect a client.
         """
         logger.info("disconnecting snap7 client")
-        return clib.Cli_Disconnect(self.pointer)
+        return self.library.Cli_Disconnect(self.pointer)
 
     @error_wrap
     def connect(self, address, rack, slot):
@@ -73,7 +73,7 @@ def connect(self, address, rack, slot):
         :param slot: slot on server.
         """
         logger.info("connecting to %s rack %s slot %s" % (address, rack, slot))
-        return clib.Cli_ConnectTo(self.pointer, c_char_p(address),
+        return self.library.Cli_ConnectTo(self.pointer, c_char_p(address),
                                   c_int(rack), c_int(slot))
 
     def db_read(self, db_number, start, size):
@@ -86,7 +86,7 @@ def db_read(self, db_number, start, size):
 
         type_ = snap7.types.wordlen_to_ctypes[snap7.types.S7WLByte]
         data = (type_ * size)()
-        result = (clib.Cli_DBRead(self.pointer, db_number, start, size,
+        result = (self.library.Cli_DBRead(self.pointer, db_number, start, size,
                                   byref(data)))
         check_error(result, context="client")
         return bytearray(data)
@@ -103,7 +103,7 @@ def db_write(self, db_number, start, size, data):
         logger.debug("db_write db_number:%s start:%s size:%s data:%s" %
                      (db_number, start, size, data))
 
-        return clib.Cli_DBWrite(self.pointer, db_number, start, size,
+        return self.library.Cli_DBWrite(self.pointer, db_number, start, size,
                                 byref(_buffer))
 
     def db_full_upload(self, _type, block_num):
@@ -116,7 +116,7 @@ def db_full_upload(self, _type, block_num):
         size = c_int(sizeof(_buffer))
         block_type = snap7.types.block_types[_type]
 
-        result = clib.Cli_FullUpload(self.pointer, block_type, block_num,
+        result = self.library.Cli_FullUpload(self.pointer, block_type, block_num,
                                      byref(_buffer), byref(size))
 
         check_error(result, context="client")
@@ -136,7 +136,7 @@ def db_upload(self, block_num):
         _buffer = buffer_type()
         size = c_int(sizeof(_buffer))
 
-        result = clib.Cli_Upload(self.pointer, block_type, block_num,
+        result = self.library.Cli_Upload(self.pointer, block_type, block_num,
                                  byref(_buffer), byref(size))
 
         check_error(result, context="client")
@@ -153,7 +153,7 @@ def download(self, db_number, data, size):
 
         _buffer = bytearray_to_buffer(data)
 
-        result = clib.Cli_Download(self.pointer, db_number,
+        result = self.library.Cli_Download(self.pointer, db_number,
                                    byref(_buffer), size)
         return result
 
@@ -162,7 +162,7 @@ def db_get(self, db_number):
         """
         logging.debug("db_get db_number: %s" % db_number)
         _buffer = buffer_type()
-        result = clib.Cli_DBGet(self.pointer, db_number, byref(_buffer),
+        result = self.library.Cli_DBGet(self.pointer, db_number, byref(_buffer),
                                 byref(c_int(buffer_size)))
         check_error(result, context="client")
         return bytearray(_buffer)
@@ -175,7 +175,7 @@ def read_area(self, area, dbnumber, start, amount):
         logging.debug("reading area: %s dbnumber: %s start: %s: amount %s: "
                       "wordlen: %s" % (area, dbnumber, start, amount, wordlen))
         data = (wordlen_to_ctypes[wordlen] * amount)()
-        result = clib.Cli_ReadArea(self.pointer, area, dbnumber, start, amount,
+        result = self.library.Cli_ReadArea(self.pointer, area, dbnumber, start, amount,
                                    wordlen, byref(data))
         check_error(result, context="client")
         return data
@@ -193,7 +193,7 @@ def write_area(self, area, dbnumber, start, amount, data):
 
         _buffer = bytearray_to_buffer(data)
 
-        return clib.Cli_WriteArea(self.pointer, area, dbnumber, start, amount,
+        return self.library.Cli_WriteArea(self.pointer, area, dbnumber, start, amount,
                                   wordlen, byref(_buffer))
 
     def list_blocks(self):
@@ -203,7 +203,7 @@ def list_blocks(self):
         """
         logging.debug("listing blocks")
         blocksList = BlocksList()
-        result = clib.Cli_ListBlocks(self.pointer, byref(blocksList))
+        result = self.library.Cli_ListBlocks(self.pointer, byref(blocksList))
         check_error(result, context="client")
         logging.debug("blocks: %s" % blocksList)
         return blocksList
@@ -214,7 +214,7 @@ def list_blocks_of_type(self, blocktype, size):
                       (blocktype, size))
         data = (c_int * 10)()
         count = c_int(size)
-        result = clib.Cli_ListBlocksOfType(self.pointer, blocktype,
+        result = self.library.Cli_ListBlocksOfType(self.pointer, blocktype,
                                            byref(data),
                                            byref(count))
 
@@ -226,12 +226,12 @@ def list_blocks_of_type(self, blocktype, size):
     def set_session_password(self, password):
         """Send the password to the PLC to meet its security level."""
         assert len(password) <= 8, 'maximum password length is 8'
-        return clib.Cli_SetSessionPassword(self.pointer, c_char_p(password))
+        return self.library.Cli_SetSessionPassword(self.pointer, c_char_p(password))
 
     @error_wrap
     def clear_session_password(self):
         """Clears the password set for the current session (logout)."""
-        return clib.Cli_ClearSessionPassword(self.pointer)
+        return self.library.Cli_ClearSessionPassword(self.pointer)
 
 
 # TODO: implement
diff --git a/snap7/partner.py b/snap7/partner.py
@@ -14,7 +14,6 @@
 from snap7.types import S7Object
 
 logger = logging.getLogger(__name__)
-clib = load_library()
 
 
 def error_wrap(func):
@@ -30,6 +29,7 @@ class Partner(object):
     A snap7 partner.
     """
     def __init__(self, active=False):
+        self.library = load_library()
         self.pointer = self.create(active)
 
     def as_b_send(self):
@@ -38,36 +38,36 @@ def as_b_send(self):
         it terminates immediately, a completion method is needed to know when
         the transfer is complete.
         """
-        return clib.Par_AsBSend(self.pointer)
+        return self.library.Par_AsBSend(self.pointer)
 
     def b_recv(self):
         """
         Receives a data packet from the partner. This function is
         synchronous, it waits until a packet is received or the timeout
         supplied expires.
         """
-        return clib.Par_BRecv(self.pointer)
+        return self.library.Par_BRecv(self.pointer)
 
     def b_send(self):
         """
         Sends a data packet to the partner. This function is synchronous, i.e.
         it terminates when the transfer job (send+ack) is complete.
         """
-        return clib.Par_BSend(self.pointer)
+        return self.library.Par_BSend(self.pointer)
 
     def check_as_b_recv_completion(self):
         """
         Checks if a packed received was received.
         """
-        return clib.Par_CheckAsBRecvCompletion(self.pointer)
+        return self.library.Par_CheckAsBRecvCompletion(self.pointer)
 
     def check_as_b_send_completion(self):
         """
         Checks if the current asynchronous send job was completed and terminates
         immediately.
         """
         op_result = ctypes.c_int32()
-        result = clib.Par_CheckAsBSendCompletion(self.pointer,
+        result = self.library.Par_CheckAsBSendCompletion(self.pointer,
                                                  ctypes.byref(op_result))
         return_values = {
             0: "job complete",
@@ -84,30 +84,30 @@ def create(self, active=False):
         :param active: 0
         :returns: a pointer to the partner object
         """
-        return S7Object(clib.Par_Create(int(active)))
+        return S7Object(self.library.Par_Create(int(active)))
 
     def destroy(self):
         """
         Destroy a Partner of given handle.
         Before destruction the Partner is stopped, all clients disconnected and
         all shared memory blocks released.
         """
-        return clib.Par_Destroy(ctypes.byref(self.pointer))
+        return self.library.Par_Destroy(ctypes.byref(self.pointer))
 
     def get_last_error(self):
         """
         Returns the last job result.
         """
         error = ctypes.c_int32()
-        result = clib.Par_GetLastError(self.pointer, ctypes.byref(error))
+        result = self.library.Par_GetLastError(self.pointer, ctypes.byref(error))
         check_error(result, "partner")
         return error
 
     def get_param(self):
         """
         Reads an internal Partner object parameter.
         """
-        return clib.Par_GetParam(self.pointer)
+        return self.library.Par_GetParam(self.pointer)
 
     def get_stats(self):
         """
@@ -119,7 +119,7 @@ def get_stats(self):
         recv = ctypes.c_uint32()
         send_errors = ctypes.c_uint32()
         recv_errors = ctypes.c_uint32()
-        result = clib.Par_GetStats(self.pointer, ctypes.byref(sent),
+        result = self.library.Par_GetStats(self.pointer, ctypes.byref(sent),
                                    ctypes.byref(recv),
                                    ctypes.byref(send_errors),
                                    ctypes.byref(recv_errors))
@@ -131,7 +131,7 @@ def get_status(self):
         Returns the Partner status.
         """
         status = ctypes.c_int32()
-        result = clib.Par_GetStatus(self.pointer, ctypes.byref(status))
+        result = self.library.Par_GetStatus(self.pointer, ctypes.byref(status))
         check_error(result, "partner")
         return status
 
@@ -141,7 +141,7 @@ def get_times(self):
         """
         send_time = ctypes.c_int32()
         recv_time = ctypes.c_int32()
-        result = clib.Par_GetTimes(self.pointer, ctypes.byref(send_time),
+        result = self.library.Par_GetTimes(self.pointer, ctypes.byref(send_time),
                                    ctypes.byref(recv_time))
         check_error(result, "partner")
         return send_time, recv_time
@@ -150,29 +150,29 @@ def set_param(self):
         """
         Sets an internal Partner object parameter.
         """
-        return clib.Par_SetParam(self.pointer)
+        return self.library.Par_SetParam(self.pointer)
 
     def set_recv_callback(self):
         """
         Sets the user callback that the Partner object has to call when a data
         packet is incoming.
         """
-        return clib.Par_SetRecvCallback(self.pointer)
+        return self.library.Par_SetRecvCallback(self.pointer)
 
     def set_send_callback(self):
         """
         Sets the user callback that the Partner object has to call when the
         asynchronous data sent is complete.
         """
-        return clib.Par_SetSendCallback(self.pointer)
+        return self.library.Par_SetSendCallback(self.pointer)
 
     @error_wrap
     def start(self):
         """
         Starts the Partner and binds it to the specified IP address and the
         IsoTCP port.
         """
-        return clib.Par_Start(self.pointer)
+        return self.library.Par_Start(self.pointer)
 
     @error_wrap
     def start_to(self, ip):
@@ -182,17 +182,17 @@ def start_to(self, ip):
         """
         assert re.match(ipv4, ip), '%s is invalid ipv4' % ip
         logger.info("starting server to %s:102" % ip)
-        return clib.Par_StartTo(self.pointer, ip)
+        return self.library.Par_StartTo(self.pointer, ip)
 
     def stop(self):
         """
         Stops the Partner, disconnects gracefully the remote partner.
         """
-        return clib.Par_Stop(self.pointer)
+        return self.library.Par_Stop(self.pointer)
 
     def wait_as_b_send_completion(self):
         """
         Waits until the current asynchronous send job is done or the timeout
         expires.
         """
-        return clib.Par_WaitAsBSendCompletion(self.pointer)
+        return self.library.Par_WaitAsBSendCompletion(self.pointer)
diff --git a/snap7/server.py b/snap7/server.py
diff --git a/test/test_server.py b/test/test_server.py
