Import cleanups (#362)

* Use absolute `canopen` instead of relative imports
* Ensure canopen imports after system imports
* Fix isinstance bug in TPDO.stop()
* Change const from objectdictionary.* to datatypes.* in objectdictionary.eds.py for consistency
* Save typing by using ObjectDictionary instead of objectdictionary.ObjectDictionary

Author: sveinse

canopen/__init__.py

@@ -1,10 +1,10 @@
-from .network import Network, NodeScanner
-from .node import RemoteNode, LocalNode
-from .sdo import SdoCommunicationError, SdoAbortedError
-from .objectdictionary import import_od, export_od, ObjectDictionary, ObjectDictionaryError
-from .profiles.p402 import BaseNode402
+from canopen.network import Network, NodeScanner
+from canopen.node import RemoteNode, LocalNode
+from canopen.sdo import SdoCommunicationError, SdoAbortedError
+from canopen.objectdictionary import import_od, export_od, ObjectDictionary, ObjectDictionaryError
+from canopen.profiles.p402 import BaseNode402
 try:
-    from ._version import version as __version__
+    from canopen._version import version as __version__
 except ImportError:
     # package is not installed
     __version__ = "unknown"

canopen/network.py

@@ -17,13 +17,13 @@
     class Listener:
         """ Dummy listener """
 
-from .node import RemoteNode, LocalNode
-from .sync import SyncProducer
-from .timestamp import TimeProducer
-from .nmt import NmtMaster
-from .lss import LssMaster
-from .objectdictionary.eds import import_from_node
-from .objectdictionary import ObjectDictionary
+from canopen.node import RemoteNode, LocalNode
+from canopen.sync import SyncProducer
+from canopen.timestamp import TimeProducer
+from canopen.nmt import NmtMaster
+from canopen.lss import LssMaster
+from canopen.objectdictionary.eds import import_from_node
+from canopen.objectdictionary import ObjectDictionary
 
 logger = logging.getLogger(__name__)
 

canopen/nmt.py

@@ -4,8 +4,6 @@
 import time
 from typing import Callable, Optional
 
-from .network import CanError
-
 logger = logging.getLogger(__name__)
 
 NMT_STATES = {

canopen/node/__init__.py

@@ -1,2 +1,2 @@
-from .remote import RemoteNode
-from .local import LocalNode
+from canopen.node.remote import RemoteNode
+from canopen.node.local import LocalNode

canopen/node/base.py

@@ -1,5 +1,5 @@
 from typing import TextIO, Union
-from .. import objectdictionary
+from canopen.objectdictionary import ObjectDictionary, import_od
 
 
 class BaseNode:
@@ -15,14 +15,12 @@ class BaseNode:
     def __init__(
         self,
         node_id: int,
-        object_dictionary: Union[objectdictionary.ObjectDictionary, str, TextIO],
+        object_dictionary: Union[ObjectDictionary, str, TextIO],
     ):
         self.network = None
 
-        if not isinstance(object_dictionary,
-                          objectdictionary.ObjectDictionary):
-            object_dictionary = objectdictionary.import_od(
-                object_dictionary, node_id)
+        if not isinstance(object_dictionary, ObjectDictionary):
+            object_dictionary = import_od(object_dictionary, node_id)
         self.object_dictionary = object_dictionary
 
         self.id = node_id or self.object_dictionary.node_id

canopen/node/local.py

@@ -1,12 +1,13 @@
 import logging
 from typing import Dict, Union
 
-from .base import BaseNode
-from ..sdo import SdoServer, SdoAbortedError
-from ..pdo import PDO, TPDO, RPDO
-from ..nmt import NmtSlave
-from ..emcy import EmcyProducer
-from .. import objectdictionary
+from canopen.node.base import BaseNode
+from canopen.sdo import SdoServer, SdoAbortedError
+from canopen.pdo import PDO, TPDO, RPDO
+from canopen.nmt import NmtSlave
+from canopen.emcy import EmcyProducer
+from canopen.objectdictionary import ObjectDictionary
+from canopen import objectdictionary
 
 logger = logging.getLogger(__name__)
 
@@ -16,7 +17,7 @@ class LocalNode(BaseNode):
     def __init__(
         self,
         node_id: int,
-        object_dictionary: Union[objectdictionary.ObjectDictionary, str],
+        object_dictionary: Union[ObjectDictionary, str],
     ):
         super(LocalNode, self).__init__(node_id, object_dictionary)
 

canopen/node/remote.py

@@ -1,16 +1,12 @@
 import logging
 from typing import Union, TextIO
 
-from ..sdo import SdoClient
-from ..nmt import NmtMaster
-from ..emcy import EmcyConsumer
-from ..pdo import TPDO, RPDO, PDO
-from ..objectdictionary import Record, Array, Variable
-from .base import BaseNode
-
-import canopen
-
-from canopen import objectdictionary
+from canopen.sdo import SdoClient, SdoCommunicationError, SdoAbortedError
+from canopen.nmt import NmtMaster
+from canopen.emcy import EmcyConsumer
+from canopen.pdo import TPDO, RPDO, PDO
+from canopen.objectdictionary import Record, Array, Variable, ObjectDictionary
+from canopen.node.base import BaseNode
 
 logger = logging.getLogger(__name__)
 
@@ -31,7 +27,7 @@ class RemoteNode(BaseNode):
     def __init__(
         self,
         node_id: int,
-        object_dictionary: Union[objectdictionary.ObjectDictionary, str, TextIO],
+        object_dictionary: Union[ObjectDictionary, str, TextIO],
         load_od: bool = False,
     ):
         super(RemoteNode, self).__init__(node_id, object_dictionary)
@@ -138,9 +134,9 @@ def __load_configuration_helper(self, index, subindex, name, value):
                     index=index,
                     name=name,
                     value=value)))
-        except canopen.SdoCommunicationError as e:
+        except SdoCommunicationError as e:
             logger.warning(str(e))
-        except canopen.SdoAbortedError as e:
+        except SdoAbortedError as e:
             # WORKAROUND for broken implementations: the SDO is set but the error
             # "Attempt to write a read-only object" is raised any way.
             if e.code != 0x06010002:

canopen/objectdictionary/__init__.py

@@ -9,7 +9,7 @@
     from collections import MutableMapping, Mapping
 import logging
 
-from .datatypes import *
+from canopen.objectdictionary.datatypes import *
 
 logger = logging.getLogger(__name__)
 
@@ -42,10 +42,10 @@ def export_od(od, dest:Union[str,TextIO,None]=None, doc_type:Optional[str]=None)
     assert doc_type in doctypes
 
     if doc_type == "eds":
-        from . import eds
+        from canopen.objectdictionary import eds
         return eds.export_eds(od, dest)
     elif doc_type == "dcf":
-        from . import eds
+        from canopen.objectdictionary import eds
         return eds.export_dcf(od, dest)
 
     # If dest is opened in this fn, it should be closed
@@ -78,10 +78,10 @@ def import_od(
         filename = source
     suffix = filename[filename.rfind("."):].lower()
     if suffix in (".eds", ".dcf"):
-        from . import eds
+        from canopen.objectdictionary import eds
         return eds.import_eds(source, node_id)
     elif suffix == ".epf":
-        from . import epf
+        from canopen.objectdictionary import epf
         return epf.import_epf(source)
     else:
         raise NotImplementedError("No support for this format")

canopen/objectdictionary/eds.py

@@ -2,13 +2,13 @@
 import logging
 import re
 
-from canopen.objectdictionary import datatypes
-
 try:
     from configparser import RawConfigParser, NoOptionError, NoSectionError
 except ImportError:
     from ConfigParser import RawConfigParser, NoOptionError, NoSectionError
+
 from canopen import objectdictionary
+from canopen.objectdictionary import ObjectDictionary, datatypes
 from canopen.sdo import SdoClient
 
 logger = logging.getLogger(__name__)
@@ -38,7 +38,7 @@ def import_eds(source, node_id):
         if not hasattr(source, "read"):
             fp.close()
 
-    od = objectdictionary.ObjectDictionary()
+    od = ObjectDictionary()
 
     if eds.has_section("FileInfo"):
         od.__edsFileInfo = {
@@ -130,7 +130,7 @@ def import_eds(source, node_id):
                 arr = objectdictionary.Array(name, index)
                 last_subindex = objectdictionary.Variable(
                     "Number of entries", index, 0)
-                last_subindex.data_type = objectdictionary.UNSIGNED8
+                last_subindex.data_type = datatypes.UNSIGNED8
                 arr.add_member(last_subindex)
                 arr.add_member(build_variable(eds, section, node_id, index, 1))
                 arr.storage_location = storage_location
@@ -179,7 +179,7 @@ def import_from_node(node_id, network):
     :param network: network object
     """
     # Create temporary SDO client
-    sdo_client = SdoClient(0x600 + node_id, 0x580 + node_id, objectdictionary.ObjectDictionary())
+    sdo_client = SdoClient(0x600 + node_id, 0x580 + node_id, ObjectDictionary())
     sdo_client.network = network
     # Subscribe to SDO responses
     network.subscribe(0x580 + node_id, sdo_client.on_response)
@@ -219,11 +219,11 @@ def _signed_int_from_hex(hex_str, bit_length):
 
 
 def _convert_variable(node_id, var_type, value):
-    if var_type in (objectdictionary.OCTET_STRING, objectdictionary.DOMAIN):
+    if var_type in (datatypes.OCTET_STRING, datatypes.DOMAIN):
         return bytes.fromhex(value)
-    elif var_type in (objectdictionary.VISIBLE_STRING, objectdictionary.UNICODE_STRING):
+    elif var_type in (datatypes.VISIBLE_STRING, datatypes.UNICODE_STRING):
         return value
-    elif var_type in objectdictionary.FLOAT_TYPES:
+    elif var_type in datatypes.FLOAT_TYPES:
         return float(value)
     else:
         # COB-ID can contain '$NODEID+' so replace this with node_id before converting
@@ -237,11 +237,11 @@ def _convert_variable(node_id, var_type, value):
 def _revert_variable(var_type, value):
     if value is None:
         return None
-    if var_type in (objectdictionary.OCTET_STRING, objectdictionary.DOMAIN):
+    if var_type in (datatypes.OCTET_STRING, datatypes.DOMAIN):
         return bytes.hex(value)
-    elif var_type in (objectdictionary.VISIBLE_STRING, objectdictionary.UNICODE_STRING):
+    elif var_type in (datatypes.VISIBLE_STRING, datatypes.UNICODE_STRING):
         return value
-    elif var_type in objectdictionary.FLOAT_TYPES:
+    elif var_type in datatypes.FLOAT_TYPES:
         return value
     else:
         return "0x%02X" % value
@@ -273,14 +273,14 @@ def build_variable(eds, section, node_id, index, subindex=0):
         except NoSectionError:
             logger.warning("%s has an unknown or unsupported data type (%X)", name, var.data_type)
             # Assume DOMAIN to force application to interpret the byte data
-            var.data_type = objectdictionary.DOMAIN
+            var.data_type = datatypes.DOMAIN
 
     var.pdo_mappable = bool(int(eds.get(section, "PDOMapping", fallback="0"), 0))
 
     if eds.has_option(section, "LowLimit"):
         try:
             min_string = eds.get(section, "LowLimit")
-            if var.data_type in objectdictionary.SIGNED_TYPES:
+            if var.data_type in datatypes.SIGNED_TYPES:
                 var.min = _signed_int_from_hex(min_string, _calc_bit_length(var.data_type))
             else:
                 var.min = int(min_string, 0)
@@ -289,7 +289,7 @@ def build_variable(eds, section, node_id, index, subindex=0):
     if eds.has_option(section, "HighLimit"):
         try:
             max_string = eds.get(section, "HighLimit")
-            if var.data_type in objectdictionary.SIGNED_TYPES:
+            if var.data_type in datatypes.SIGNED_TYPES:
                 var.max = _signed_int_from_hex(max_string, _calc_bit_length(var.data_type))
             else:
                 var.max = int(max_string, 0)
@@ -341,7 +341,7 @@ def export_common(var, eds, section):
             eds.set(section, "StorageLocation", var.storage_location)
 
     def export_variable(var, eds):
-        if isinstance(var.parent, objectdictionary.ObjectDictionary):
+        if isinstance(var.parent, ObjectDictionary):
             # top level variable
             section = "%04X" % var.index
         else:

canopen/objectdictionary/epf.py

@@ -3,7 +3,9 @@
 except ImportError:
     import xml.etree.ElementTree as etree
 import logging
+
 from canopen import objectdictionary
+from canopen.objectdictionary import ObjectDictionary
 
 logger = logging.getLogger(__name__)
 
@@ -32,7 +34,7 @@ def import_epf(epf):
         The Object Dictionary.
     :rtype: canopen.ObjectDictionary
     """
-    od = objectdictionary.ObjectDictionary()
+    od = ObjectDictionary()
     if etree.iselement(epf):
         tree = epf
     else: