[device] Make data access read-only to avoid copy

Author: salkinium

tools/device/modm_devices/access.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import copy
+
+def copy_keys(src, *keys):
+    dest = {};
+    for key in keys:
+        conv = lambda o: o
+        if isinstance(key, tuple):
+            key, conv = key
+        if key in src:
+            dest[key] = conv(src[key])
+    return dest
+
+def copy_deep(obj):
+    return copy.deepcopy(obj)
+
+
+class ReadOnlyList(list):
+    def __readonly__(self, *args, **kwargs):
+        raise RuntimeError("You are trying to modify read-only DeviceFile data!")
+    pop = __readonly__
+    remove = __readonly__
+    append = __readonly__
+    clear = __readonly__
+    extend = __readonly__
+    insert = __readonly__
+    reverse = __readonly__
+    __copy__ = list.copy
+    __deepcopy__ = copy._deepcopy_dispatch.get(list)
+    del __readonly__
+
+
+class ReadOnlyDict(dict):
+    def __readonly__(self, *args, **kwargs):
+        raise RuntimeError("You are trying to modify read-only DeviceFile data!")
+    __setitem__ = __readonly__
+    __delitem__ = __readonly__
+    pop = __readonly__
+    popitem = __readonly__
+    clear = __readonly__
+    update = __readonly__
+    setdefault = __readonly__
+    __copy__ = dict.copy
+    __deepcopy__ = copy._deepcopy_dispatch.get(dict)
+    del __readonly__
+
+
+def read_only(obj):
+    if isinstance(obj, dict):
+        return ReadOnlyDict(obj)
+    if isinstance(obj, list):
+        return ReadOnlyList(obj)
+    return obj

tools/device/modm_devices/device.py

@@ -21,26 +21,19 @@ def __init__(self,
         self.partname = identifier.string
         self.device_file = device_file
 
-        self._properties = None
-
-    def __parse_properties(self):
-        """
-        Perform a lazy initialization of the driver property tree.
-        """
-        if self._properties is None:
-            self._properties = self.device_file.get_properties(self._identifier)
+        self.__properties = None
 
     @property
-    def properties(self):
-        self.__parse_properties()
-        return copy.deepcopy(self._properties)
+    def _properties(self):
+        if self.__properties is None:
+            self.__properties = self.device_file.get_properties(self._identifier)
+        return self.__properties
 
     @property
     def identifier(self):
-        return self._identifier.copy()
+        return self._identifier
 
     def get_all_drivers(self, name):
-        self.__parse_properties()
         parts = name.split(":")
         results = []
 
@@ -58,7 +51,7 @@ def get_all_drivers(self, name):
                                   "The name must contain no or one ':' to "
                                   "separate type and name.".format(name))
 
-        return copy.deepcopy(results)
+        return results
 
     def get_driver(self, name):
         results = self.get_all_drivers(name)

tools/device/modm_devices/device_file.py

@@ -6,12 +6,14 @@
 # All rights reserved.
 
 import lxml.etree
+import copy
 
 from collections import defaultdict
 
 from .device import Device
 from .device_identifier import DeviceIdentifier
 from .device_identifier import MultiDeviceIdentifier
+from .access import read_only
 
 from .exception import ParserException
 
@@ -65,8 +67,6 @@ def is_valid(node, identifier: DeviceIdentifier):
 
     def get_properties(self, identifier: DeviceIdentifier):
         class Converter:
-            """
-            """
             def __init__(self, identifier: DeviceIdentifier):
                 self.identifier = identifier
 
@@ -106,15 +106,15 @@ def to_dict(self, t):
                                 raise ParserException("Attribute '{}' cannot be a list!".format(k))
                             k = k.replace(DeviceFile._PREFIX_ATTRIBUTE, '')
                             v = v[0]
-                        dk[k] = v
+                        dk[k] = read_only(v)
                     d = {t.tag: dk}
                 if list(attrib.keys()) == ['value']:
                     d[t.tag] = attrib['value']
                 elif len(attrib):
                     if any(k in d[t.tag] for k in attrib.keys()):
                         raise ParserException("Node children are overwriting attribute '{}'!".format(k))
                     d[t.tag].update(attrib.items())
-                return d
+                return read_only({k:read_only(v) for k,v in d.items()})
 
         properties = Converter(identifier).to_dict(self.rootnode.find("device"))
         return properties["device"]