Rename hardware_device into lofar_device

tangostationcontrol/README.md

@@ -3,7 +3,7 @@
 This code provides an attribute_wrapper class in place of attributes for tango devices. the attribute wrappers contain additional code 
 that moves a lot of the complexity and redundant code to the background. 
 
-The tango Device class is also abstracted further to a "hardware_device" class. This class wraps 
+The tango Device class is also abstracted further to a "lofar_device" class. This class wraps 
 
 The only things required on the users part are to declare the attributes using the attribute_wrapper (see `example/example_device`),
 declare what client the attribute has to use in the initialisation and provide support for the used clients. 

tangostationcontrol/tangostationcontrol/devices/abstract_device.py

@@ -20,7 +20,7 @@ logger = logging.getLogger()
 
 
 class AbstractDeviceMetas(DeviceMeta, ABCMeta):
-    """Collects meta classes to allow hardware_device to be both a Device and an ABC. """
+    """Collects meta classes to allow lofar_device to be both a Device and an ABC. """
 
     def __new__(mcs, name, bases, namespace, **kwargs):
         cls = ABCMeta.__new__(mcs, name, bases, namespace, **kwargs)

tangostationcontrol/tangostationcontrol/devices/boot.py

@@ -24,7 +24,7 @@ import numpy
 from device_decorators import *
 
 from tangostationcontrol.common.entry import entry
-from tangostationcontrol.devices.hardware_device import hardware_device
+from tangostationcontrol.devices.lofar_device import lofar_device
 from tangostationcontrol.common.lofar_logging import device_logging_to_python, log_exceptions
 
 import logging
@@ -184,7 +184,7 @@ class DevicesInitialiser(Thread):
         self.set_status(f"[restarting {device_name}] Succesfully started.")
 
 @device_logging_to_python()
-class Boot(hardware_device):
+class Boot(lofar_device):
     # -----------------
     # Device Properties
     # -----------------

tangostationcontrol/tangostationcontrol/devices/docker_device.py

@@ -25,13 +25,13 @@ from device_decorators import *
 from tangostationcontrol.common.entrypoint import entry
 from tangostationcontrol.clients.docker_client import DockerClient
 from tangostationcontrol.clients.attribute_wrapper import attribute_wrapper
-from tangostationcontrol.devices.hardware_device import hardware_device
+from tangostationcontrol.devices.lofar_device import lofar_device
 from tangostationcontrol.common.lofar_logging import device_logging_to_python, log_exceptions
 
 __all__ = ["Docker", "main"]
 
 @device_logging_to_python()
-class Docker(hardware_device):
+class Docker(lofar_device):
     # -----------------
     # Device Properties
     # -----------------

tangostationcontrol/tangostationcontrol/devices/hardware_device.py → tangostationcontrol/tangostationcontrol/devices/lofar_device.py

@@ -28,12 +28,12 @@ from tangostationcontrol.devices.abstract_device import AbstractDeviceMetas
 from tangostationcontrol.devices.device_decorators import only_in_states, fault_on_error
 
 
-__all__ = ["hardware_device"]
+__all__ = ["lofar_device"]
 
 import logging
 logger = logging.getLogger()
 
-class hardware_device(Device, metaclass=AbstractDeviceMetas):
+class lofar_device(Device, metaclass=AbstractDeviceMetas):
     """
 
     **Properties:**

tangostationcontrol/tangostationcontrol/devices/opcua_device.py

@@ -28,11 +28,11 @@ import asyncio
 from tangostationcontrol.common.lofar_logging import device_logging_to_python, log_exceptions
 from tangostationcontrol.clients.opcua_client import OPCUAConnection
 from tangostationcontrol.devices.device_decorators import *
-from tangostationcontrol.devices.hardware_device import hardware_device
+from tangostationcontrol.devices.lofar_device import lofar_device
 
 __all__ = ["opcua_device", "main"]
 
-class opcua_device(hardware_device):
+class opcua_device(lofar_device):
     """
 
     **Properties:**

tangostationcontrol/tangostationcontrol/examples/HW_device_template.py

@@ -13,15 +13,15 @@
 from tango.server import run
 # Additional import
 
-from tangostationcontrol.devices.hardware_device import hardware_device
+from tangostationcontrol.devices.lofar_device import lofar_device
 
 
 __all__ = ["HW_dev"]
 
 
-class HW_dev(hardware_device):
+class HW_dev(lofar_device):
     """
-    This class is the minimal (read empty) implementation of a class using 'hardware_device'
+    This class is the minimal (read empty) implementation of a class using 'lofar_device'
     """
 
     # ----------

tangostationcontrol/tangostationcontrol/examples/load_from_disk/ini_device.py

@@ -18,7 +18,7 @@ import numpy
 
 # Additional import
 from tangostationcontrol.clients.attribute_wrapper import attribute_wrapper
-from tangostationcontrol.devices.hardware_device import hardware_device
+from tangostationcontrol.devices.lofar_device import lofar_device
 from tangostationcontrol.examples.load_from_disk.ini_client import *
 
 __all__ = ["ini_device"]
@@ -50,9 +50,9 @@ def write_ini_file(filename):
 
 
 
-class ini_device(hardware_device):
+class ini_device(lofar_device):
     """
-    This class is the minimal (read empty) implementation of a class using 'hardware_device'
+    This class is the minimal (read empty) implementation of a class using 'lofar_device'
     """
 
     # ----------

tangostationcontrol/tangostationcontrol/examples/snmp/snmp.py

@@ -19,14 +19,14 @@ from tango import AttrWriteType
 # Additional import
 from tangostationcontrol.examples.snmp.snmp_client import SNMP_client
 from tangostationcontrol.clients.attribute_wrapper import attribute_wrapper
-from tangostationcontrol.devices.hardware_device import hardware_device
+from tangostationcontrol.devices.lofar_device import lofar_device
 
 import numpy
 
 __all__ = ["SNMP", "main"]
 
 
-class SNMP(hardware_device):
+class SNMP(lofar_device):
     """
 
     **Properties:**

tangostationcontrol/tangostationcontrol/test/clients/test_attr_wrapper.py

@@ -12,7 +12,7 @@ from tango import DevState
 # Internal imports
 from tangostationcontrol.test.clients.test_client import test_client
 from tangostationcontrol.clients.attribute_wrapper import *
-from tangostationcontrol.devices.hardware_device import *
+from tangostationcontrol.devices.lofar_device import *
 
 # Test imports
 from tango.test_context import DeviceTestContext
@@ -39,252 +39,252 @@ def dev_init(device):
 
 class TestAttributeTypes(base.TestCase):
 
-    class str_scalar_device(hardware_device):
+    class str_scalar_device(lofar_device):
         scalar_R = attribute_wrapper(comms_annotation="str_scalar_R", datatype=numpy.str)
         scalar_RW = attribute_wrapper(comms_annotation="str_scalar_RW", datatype=numpy.str, access=AttrWriteType.READ_WRITE)
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class bool_scalar_device(hardware_device):
+    class bool_scalar_device(lofar_device):
         scalar_R = attribute_wrapper(comms_annotation="bool_scalar_R", datatype=numpy.bool_)
         scalar_RW = attribute_wrapper(comms_annotation="bool_scalar_RW", datatype=numpy.bool_, access=AttrWriteType.READ_WRITE)
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class float32_scalar_device(hardware_device):
+    class float32_scalar_device(lofar_device):
         scalar_R = attribute_wrapper(comms_annotation="float32_scalar_R", datatype=numpy.float32)
         scalar_RW = attribute_wrapper(comms_annotation="float32_scalar_RW", datatype=numpy.float32, access=AttrWriteType.READ_WRITE)
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class float64_scalar_device(hardware_device):
+    class float64_scalar_device(lofar_device):
         scalar_R = attribute_wrapper(comms_annotation="float64_scalar_R", datatype=numpy.float64)
         scalar_RW = attribute_wrapper(comms_annotation="float64_scalar_RW", datatype=numpy.float64, access=AttrWriteType.READ_WRITE)
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class double_scalar_device(hardware_device):
+    class double_scalar_device(lofar_device):
         scalar_R = attribute_wrapper(comms_annotation="double_scalar_R", datatype=numpy.double)
         scalar_RW = attribute_wrapper(comms_annotation="double_scalar_RW", datatype=numpy.double, access=AttrWriteType.READ_WRITE)
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class uint8_scalar_device(hardware_device):
+    class uint8_scalar_device(lofar_device):
         scalar_R = attribute_wrapper(comms_annotation="uint8_scalar_R", datatype=numpy.uint8)
         scalar_RW = attribute_wrapper(comms_annotation="uint8_scalar_RW", datatype=numpy.uint8, access=AttrWriteType.READ_WRITE)
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class uint16_scalar_device(hardware_device):
+    class uint16_scalar_device(lofar_device):
         scalar_R = attribute_wrapper(comms_annotation="uint16_scalar_R", datatype=numpy.uint16)
         scalar_RW = attribute_wrapper(comms_annotation="uint16_scalar_RW", datatype=numpy.uint16, access=AttrWriteType.READ_WRITE)
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class uint32_scalar_device(hardware_device):
+    class uint32_scalar_device(lofar_device):
         scalar_R = attribute_wrapper(comms_annotation="uint32_scalar_R", datatype=numpy.uint32)
         scalar_RW = attribute_wrapper(comms_annotation="uint32_scalar_RW", datatype=numpy.uint32, access=AttrWriteType.READ_WRITE)
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class uint64_scalar_device(hardware_device):
+    class uint64_scalar_device(lofar_device):
         scalar_R = attribute_wrapper(comms_annotation="uint64_scalar_R", datatype=numpy.uint64)
         scalar_RW = attribute_wrapper(comms_annotation="uint64_scalar_RW", datatype=numpy.uint64, access=AttrWriteType.READ_WRITE)
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class int16_scalar_device(hardware_device):
+    class int16_scalar_device(lofar_device):
         scalar_R = attribute_wrapper(comms_annotation="int16_scalar_R", datatype=numpy.int16)
         scalar_RW = attribute_wrapper(comms_annotation="int16_scalar_RW", datatype=numpy.int16, access=AttrWriteType.READ_WRITE)
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class int32_scalar_device(hardware_device):
+    class int32_scalar_device(lofar_device):
         scalar_R = attribute_wrapper(comms_annotation="int32_scalar_R", datatype=numpy.int32)
         scalar_RW = attribute_wrapper(comms_annotation="int32_scalar_RW", datatype=numpy.int32, access=AttrWriteType.READ_WRITE)
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class int64_scalar_device(hardware_device):
+    class int64_scalar_device(lofar_device):
         scalar_R = attribute_wrapper(comms_annotation="int64_scalar_R", datatype=numpy.int64)
         scalar_RW = attribute_wrapper(comms_annotation="int64_scalar_RW", datatype=numpy.int64, access=AttrWriteType.READ_WRITE)
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class str_spectrum_device(hardware_device):
+    class str_spectrum_device(lofar_device):
         spectrum_R = attribute_wrapper(comms_annotation="str_spectrum_R", datatype=numpy.str, dims=spectrum_dims)
         spectrum_RW = attribute_wrapper(comms_annotation="str_spectrum_RW", datatype=numpy.str, access=AttrWriteType.READ_WRITE, dims=spectrum_dims)
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class bool_spectrum_device(hardware_device):
+    class bool_spectrum_device(lofar_device):
         spectrum_R = attribute_wrapper(comms_annotation="bool_spectrum_R", datatype=numpy.bool_, dims=spectrum_dims)
         spectrum_RW = attribute_wrapper(comms_annotation="bool_spectrum_RW", datatype=numpy.bool_, access=AttrWriteType.READ_WRITE, dims=spectrum_dims)
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class float32_spectrum_device(hardware_device):
+    class float32_spectrum_device(lofar_device):
         spectrum_R = attribute_wrapper(comms_annotation="float32_spectrum_R", datatype=numpy.float32, dims=spectrum_dims)
         spectrum_RW = attribute_wrapper(comms_annotation="float32_spectrum_RW", datatype=numpy.float32, access=AttrWriteType.READ_WRITE, dims=spectrum_dims)
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class float64_spectrum_device(hardware_device):
+    class float64_spectrum_device(lofar_device):
         spectrum_R = attribute_wrapper(comms_annotation="float64_spectrum_R", datatype=numpy.float64, dims=spectrum_dims)
         spectrum_RW = attribute_wrapper(comms_annotation="float64_spectrum_RW", datatype=numpy.float64, access=AttrWriteType.READ_WRITE, dims=spectrum_dims)
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class double_spectrum_device(hardware_device):
+    class double_spectrum_device(lofar_device):
         spectrum_R = attribute_wrapper(comms_annotation="double_spectrum_R", datatype=numpy.double, dims=spectrum_dims)
         spectrum_RW = attribute_wrapper(comms_annotation="double_spectrum_RW", datatype=numpy.double, access=AttrWriteType.READ_WRITE, dims=spectrum_dims)
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class uint8_spectrum_device(hardware_device):
+    class uint8_spectrum_device(lofar_device):
         spectrum_R = attribute_wrapper(comms_annotation="uint8_spectrum_R", datatype=numpy.uint8, dims=spectrum_dims)
         spectrum_RW = attribute_wrapper(comms_annotation="uint8_spectrum_RW", datatype=numpy.uint8, access=AttrWriteType.READ_WRITE, dims=spectrum_dims)
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class uint16_spectrum_device(hardware_device):
+    class uint16_spectrum_device(lofar_device):
         spectrum_R = attribute_wrapper(comms_annotation="uint16_spectrum_R", datatype=numpy.uint16, dims=spectrum_dims)
         spectrum_RW = attribute_wrapper(comms_annotation="uint16_spectrum_RW", datatype=numpy.uint16, access=AttrWriteType.READ_WRITE, dims=spectrum_dims)
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class uint32_spectrum_device(hardware_device):
+    class uint32_spectrum_device(lofar_device):
         spectrum_R = attribute_wrapper(comms_annotation="uint32_spectrum_R", datatype=numpy.uint32, dims=spectrum_dims)
         spectrum_RW = attribute_wrapper(comms_annotation="uint32_spectrum_RW", datatype=numpy.uint32, access=AttrWriteType.READ_WRITE, dims=spectrum_dims)
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class uint64_spectrum_device(hardware_device):
+    class uint64_spectrum_device(lofar_device):
         spectrum_R = attribute_wrapper(comms_annotation="uint64_spectrum_R", datatype=numpy.uint64, dims=spectrum_dims)
         spectrum_RW = attribute_wrapper(comms_annotation="uint64_spectrum_RW", datatype=numpy.uint64, access=AttrWriteType.READ_WRITE, dims=spectrum_dims)
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class int16_spectrum_device(hardware_device):
+    class int16_spectrum_device(lofar_device):
         spectrum_R = attribute_wrapper(comms_annotation="int16_spectrum_R", datatype=numpy.int16, dims=spectrum_dims)
         spectrum_RW = attribute_wrapper(comms_annotation="int16_spectrum_RW", datatype=numpy.int16, access=AttrWriteType.READ_WRITE, dims=spectrum_dims)
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class int32_spectrum_device(hardware_device):
+    class int32_spectrum_device(lofar_device):
         spectrum_R = attribute_wrapper(comms_annotation="int32_spectrum_R", datatype=numpy.int32, dims=spectrum_dims)
         spectrum_RW = attribute_wrapper(comms_annotation="int32_spectrum_RW", datatype=numpy.int32, access=AttrWriteType.READ_WRITE, dims=spectrum_dims)
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class int64_spectrum_device(hardware_device):
+    class int64_spectrum_device(lofar_device):
         spectrum_R = attribute_wrapper(comms_annotation="int64_spectrum_R", datatype=numpy.int64, dims=spectrum_dims)
         spectrum_RW = attribute_wrapper(comms_annotation="int64_spectrum_RW", datatype=numpy.int64, access=AttrWriteType.READ_WRITE, dims=spectrum_dims)
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class str_image_device(hardware_device):
+    class str_image_device(lofar_device):
         image_R = attribute_wrapper(comms_annotation="str_image_R", datatype=numpy.str, dims=(2,3))
         image_RW = attribute_wrapper(comms_annotation="str_image_RW", datatype=numpy.str, access=AttrWriteType.READ_WRITE, dims=(2,3))
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class bool_image_device(hardware_device):
+    class bool_image_device(lofar_device):
         image_R = attribute_wrapper(comms_annotation="bool_image_R", datatype=numpy.bool_, dims=(2,3))
         image_RW = attribute_wrapper(comms_annotation="bool_image_RW", datatype=numpy.bool_, access=AttrWriteType.READ_WRITE, dims=(2,3))
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class float32_image_device(hardware_device):
+    class float32_image_device(lofar_device):
         image_R = attribute_wrapper(comms_annotation="float32_image_R", datatype=numpy.float32, dims=(2,3))
         image_RW = attribute_wrapper(comms_annotation="float32_image_RW", datatype=numpy.float32, access=AttrWriteType.READ_WRITE, dims=(2,3))
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class float64_image_device(hardware_device):
+    class float64_image_device(lofar_device):
         image_R = attribute_wrapper(comms_annotation="float64_image_R", datatype=numpy.float64, dims=(2,3))
         image_RW = attribute_wrapper(comms_annotation="float64_image_RW", datatype=numpy.float64, access=AttrWriteType.READ_WRITE, dims=(2,3))
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class double_image_device(hardware_device):
+    class double_image_device(lofar_device):
         image_R = attribute_wrapper(comms_annotation="double_image_R", datatype=numpy.double, dims=(2,3))
         image_RW = attribute_wrapper(comms_annotation="double_image_RW", datatype=numpy.double, access=AttrWriteType.READ_WRITE, dims=(2,3))
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class uint8_image_device(hardware_device):
+    class uint8_image_device(lofar_device):
         image_R = attribute_wrapper(comms_annotation="uint8_image_R", datatype=numpy.uint8, dims=(2,3))
         image_RW = attribute_wrapper(comms_annotation="uint8_image_RW", datatype=numpy.uint8, access=AttrWriteType.READ_WRITE, dims=(2,3))
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class uint16_image_device(hardware_device):
+    class uint16_image_device(lofar_device):
         image_R = attribute_wrapper(comms_annotation="uint16_image_R", datatype=numpy.uint16, dims=(2,3))
         image_RW = attribute_wrapper(comms_annotation="uint16_image_RW", datatype=numpy.uint16, access=AttrWriteType.READ_WRITE, dims=(2,3))
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class uint32_image_device(hardware_device):
+    class uint32_image_device(lofar_device):
         image_R = attribute_wrapper(comms_annotation="uint32_image_R", datatype=numpy.uint32, dims=(2,3))
         image_RW = attribute_wrapper(comms_annotation="uint32_image_RW", datatype=numpy.uint32, access=AttrWriteType.READ_WRITE, dims=(2,3))
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class uint64_image_device(hardware_device):
+    class uint64_image_device(lofar_device):
         image_R = attribute_wrapper(comms_annotation="uint64_image_R", datatype=numpy.uint64, dims=(2,3))
         image_RW = attribute_wrapper(comms_annotation="uint64_image_RW", datatype=numpy.uint64, access=AttrWriteType.READ_WRITE, dims=(2,3))
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class int16_image_device(hardware_device):
+    class int16_image_device(lofar_device):
         image_R = attribute_wrapper(comms_annotation="int16_image_R", datatype=numpy.int16, dims=(2,3))
         image_RW = attribute_wrapper(comms_annotation="int16_image_RW", datatype=numpy.int16, access=AttrWriteType.READ_WRITE, dims=(2,3))
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class int32_image_device(hardware_device):
+    class int32_image_device(lofar_device):
         image_R = attribute_wrapper(comms_annotation="int32_image_R", datatype=numpy.int32, dims=(2,3))
         image_RW = attribute_wrapper(comms_annotation="int32_image_RW", datatype=numpy.int32, access=AttrWriteType.READ_WRITE, dims=(2,3))
 
         def configure_for_initialise(self):
             dev_init(self)
 
-    class int64_image_device(hardware_device):
+    class int64_image_device(lofar_device):
         image_R = attribute_wrapper(comms_annotation="int64_image_R", datatype=numpy.int64, dims=(2,3))
         image_RW = attribute_wrapper(comms_annotation="int64_image_RW", datatype=numpy.int64, access=AttrWriteType.READ_WRITE, dims=(2,3))