Moved all device specific information to one dictionary.

Author: jfjlaros

docs/library.rst

@@ -124,19 +124,19 @@ Additionally, the ``with`` statement is supported for easy opening and closing.
     >>> with Interface('/dev/ttyACM0') as interface:
     >>>     interface.ping(10)
 
-The class instance has a public member variable named ``methods`` which
-contains the definitions of the exported methods.
+The class instance has a public member variable named ``device`` which
+contains the device definitions and its exported methods.
 
 .. code:: python
 
-    >>> list(interface.methods)
+    >>> list(interface.device['methods'])
     ['inc', 'set_led']
 
 Example of a method definition.
 
 .. code:: python
 
-    >>> interface.methods['inc']
+    >>> interface.device['methods']['inc']
     {
       'doc': 'Increment a value.',
       'index': 2,
@@ -145,13 +145,13 @@ Example of a method definition.
         {
           'doc': 'Value.',
           'name': 'a',
-          'fmt': b'h',
+          'fmt': 'h',
           'typename': 'int'
         }
       ],
       'return': {
         'doc': 'a + 1.',
-        'fmt': b'h',
+        'fmt': 'h',
         'typename': 'int'}
     }
 

simple_rpc/cli.py

@@ -61,7 +61,7 @@ def rpc_list(
     """
     with Interface(device, baudrate, wait) as interface:
         if not save:
-            for method in interface.methods.values():
+            for method in interface.device['methods'].values():
                 handle.write(_describe_method(method) + '\n\n\n')
         else:
             interface.save(save)

simple_rpc/simple_rpc.py

@@ -34,12 +34,12 @@ def __init__(
 
         self._connection = serial_for_url(
             device, do_not_open=True, baudrate=baudrate)
-        self._load = load
-        # TODO: Put all of these in one object.
-        self._version = (0, 0, 0)
-        self._endianness = '<'
-        self._size_t = 'H'
-        self.methods = {}
+        self._load = load  # TODO: Content checking.
+        self.device = {
+            'version': (0, 0, 0),
+            'endianness': '<',
+            'size_t': 'H',
+            'methods': {}}
 
         if autoconnect:
             self.open()
@@ -73,7 +73,9 @@ def _write(self: object, obj_type: any, obj: any) -> None:
         :arg obj_type: Type of the parameter.
         :arg obj: Value of the parameter.
         """
-        write(self._connection, self._endianness, self._size_t, obj_type, obj)
+        write(
+            self._connection, self.device['endianness'], self.device['size_t'],
+            obj_type, obj)
 
     def _read_byte_string(self: object) -> bytes:
         return read_byte_string(self._connection)
@@ -85,7 +87,9 @@ def _read(self: object, obj_type: any) -> any:
 
         :returns: Return value.
         """
-        return read(self._connection, self._endianness, self._size_t, obj_type)
+        return read(
+            self._connection, self.device['endianness'], self.device['size_t'],
+            obj_type)
 
     def _get_methods(self: object) -> dict:
         """Get remote procedure call methods.
@@ -97,14 +101,15 @@ def _get_methods(self: object) -> dict:
         if self._read_byte_string().decode() != _protocol:
             raise ValueError('missing protocol header')
 
-        self._version = tuple(self._read('B') for _ in range(3))
-        if self._version[0] != _version[0] or self._version[1] > _version[1]:
+        version = tuple(self._read('B') for _ in range(3))
+        if version[0] != _version[0] or version[1] > _version[1]:
             raise ValueError(
                 'version mismatch (device: {}, client: {})'.format(
-                    '.'.join(map(str, self._version)),
+                    '.'.join(map(str, version)),
                     '.'.join(map(str, _version))))
+        self.device['version'] = version
 
-        self._endianness, self._size_t = (
+        self.device['endianness'], self.device['size_t'] = (
             chr(c) for c in self._read_byte_string())
 
         methods = {}
@@ -126,16 +131,16 @@ def open(self: object) -> None:
         if self._load:
             self.load()
         else:
-            self.methods = self._get_methods()
-        for method in self.methods.values():
+            self.device['methods'] = self._get_methods()
+        for method in self.device['methods'].values():
             setattr(
                 self, method['name'], MethodType(make_function(method), self))
 
     def close(self: object) -> None:
         """Disconnect from device."""
-        for method in self.methods:
+        for method in self.device['methods']:
             delattr(self, method)
-        self.methods.clear()
+        self.device['methods'].clear()
 
     def call_method(self: object, name: str, *args: list) -> any:
         """Execute a method.
@@ -145,9 +150,9 @@ def call_method(self: object, name: str, *args: list) -> any:
 
         :returns: Return value of the method.
         """
-        if name not in self.methods:
+        if name not in self.device['methods']:
             raise ValueError('invalid method name: {}'.format(name))
-        method = self.methods[name]
+        method = self.device['methods'][name]
 
         parameters = method['parameters']
         if len(args) != len(parameters):
@@ -174,21 +179,22 @@ def save(self: object, handle: TextIO) -> None:
         :arg handle: Open file handle.
         """
         dump(
-            {
-                'version': self._version,
-                'endianness': self._endianness,
-                'size_t': self._size_t,
-                'methods': self.methods
-            },
+            #{
+            #    'version': self._version,
+            #    'endianness': self._endianness,
+            #    'size_t': self._size_t,
+            #    'methods': self.methods
+            #},
+            self.device,
             handle, width=76, default_flow_style=False)
 
     def load(self: object) -> None:
         """Load the interface definition from a file."""
-        definition = load(self._load)
-        self._version = definition['version']
-        self._endianness = definition['endianness']
-        self._size_t = definition['size_t']
-        self.methods = definition['methods']
+        self.device = load(self._load)
+        #self._version = definition['version']
+        #self._endianness = definition['endianness']
+        #self._size_t = definition['size_t']
+        #self.methods = definition['methods']
 
 
 class SerialInterface(_Interface):
@@ -225,7 +231,7 @@ def _auto_open_wrapper(
 
     @wraps(_Interface.is_open)
     def is_open(self: object) -> bool:
-        return len(self.methods) > 0
+        return len(self.device['methods']) > 0
 
     open = _auto_open(_Interface.open)
     call_method = _auto_open(_Interface.call_method)

tests/test_device.py

@@ -9,53 +9,61 @@
 class _TestDevice(object):
     def test_pre_open(self: object) -> None:
         assert not self._interface.is_open()
-        assert self._interface.methods == {}
+        assert self._interface.device['methods'] == {}
 
     def test_open(self: object) -> None:
         self._interface.open()
         assert self._interface.is_open()
-        assert self._interface.methods != {}
+        assert self._interface.device['methods'] != {}
 
     def test_version(self: object) -> None:
-        assert self._interface._version == _version
+        assert self._interface.device['version'] == _version
 
     def test_ping(self: object) -> None:
         assert self._interface.ping(3) == 3
 
     def test_type_1(self: object) -> None:
-        assert self._interface.methods['ping']['return']['typename'] == 'int'
+        assert (
+            self._interface.device['methods']['ping']['return']['typename']
+            == 'int')
 
     def test_fmt_1(self: object) -> None:
-        assert self._interface.methods['ping']['return']['fmt'] == 'B'
+        assert (
+            self._interface.device['methods']['ping']['return']['fmt'] == 'B')
 
     def test_param_1(self: object) -> None:
         assert (
-            self._interface.methods['ping']['parameters'][0]['typename'] ==
-            'int')
+            self._interface.device['methods']['ping']['parameters'][0]['typename']
+            == 'int')
 
     def test_param_2(self: object) -> None:
-        assert self._interface.methods['ping']['parameters'][0]['fmt'] == 'B'
+        assert (
+            self._interface.device['methods']['ping']['parameters'][0]['fmt']
+            == 'B')
 
     def test_param_3(self: object) -> None:
         assert (
-            self._interface.methods['ping']['parameters'][0]['name'] == 'data')
+            self._interface.device['methods']['ping']['parameters'][0]['name']
+            == 'data')
 
     def test_doc_1(self: object) -> None:
-        assert self._interface.methods['ping']['doc'] == 'Echo a value.'
+        assert (
+            self._interface.device['methods']['ping']['doc']
+            == 'Echo a value.')
 
     def test_doc_2(self: object) -> None:
         assert (
-            self._interface.methods['ping']['parameters'][0]['doc'] ==
-            'Value.')
+            self._interface.device['methods']['ping']['parameters'][0]['doc']
+            == 'Value.')
 
     def test_close(self: object) -> None:
         assert self._interface.is_open()
-        assert self._interface.methods != {}
+        assert self._interface.device['methods'] != {}
         self._interface.close()
 
     def test_post_close(self: object) -> None:
         assert not self._interface.is_open()
-        assert self._interface.methods == {}
+        assert self._interface.device['methods'] == {}
 
 
 @mark.test_device('serial')