modified classes to look exactly like dictionaries and lists

cobra/core/meta_data/cvTerm.py

@@ -177,8 +177,12 @@ def __setitem__(self, key, value):
                     raise TypeError("Resources must be put in a list")
                 dict.__setitem__(self, key, value)
             elif key == 'nested_data':
-                if not isinstance(value, CVTerm):
-                    raise TypeError("The value passed must be of type CVTerm.")
+                if isinstance(value, CVTerm):
+                    dict.__setitem__(self, key, value)
+                elif isinstance(value, dict):
+                    dict.__setitem__(self, key, CVTerm(value))
+                else:
+                    raise TypeError("The value passed has invalid format.")
                 dict.__setitem__(self, key, value)
 
         def __delitem__(self, key):

cobra/core/meta_data/history.py

@@ -18,10 +18,11 @@ def validateDate(date_text):
     return True
 
 
-class History:
+class History(dict):
     """
     Class representation of history of a given component i.e. creator,
-    created date and modification dates
+    created date and modification dates. It is basically an extended
+    dictionary with some restrictions
 
     Parameters
     ----------
@@ -33,7 +34,7 @@ class History:
     modified : list
         A list of dates about the component modification
 
-    Attributes
+    Allowed Keys
     ----------
     creator : dict
         A dictionary containong details of creator's name, email and
@@ -45,49 +46,72 @@ class History:
 
     """
 
+    VALID_KEYS = ["creators", "created", "modified"]
+
     def __init__(self, creators=[], created=None, modified=[]):
         if creators is None:
             creators = []
-        self._creators = self.ListOfCreators(creators)
+        dict.__setitem__(self, "creators", self.ListOfCreators(creators))
         if isinstance(created, str):
             validateDate(created)
-            self._created = created
+            dict.__setitem__(self, "created", created)
         elif created is None:
-            self._created = None
+            dict.__setitem__(self, "created", None)
         else:
             raise TypeError('Only None and string types are possible for '
                             '"created" date attribute')
         if modified is None:
             modified = []
-        self._modified = self.ModifiedHistory(modified)
-
-    @property
-    def creators(self):
-        return self._creators
-
-    @creators.setter
-    def creators(self, creators_list):
-        self._creators = self.ListOfCreators(creators_list)
+        dict.__setitem__(self, "modified", self.ModifiedHistory(modified))
+
+    def __getitem__(self, key):
+        if key not in self.VALID_KEYS:
+            raise ValueError("Key %s is not allowed. Only allowed "
+                             "keys are : 'creators', 'created', 'modified'"
+                             % key)
+        return dict.__getitem__(self, key)
+
+    def __setitem__(self, key, value):
+        """Restricting the keys and values that can be set.
+           Only allowed keys are : 'id', 'name', 'key', 'value', 'uri''
+        """
+        if key not in self.VALID_KEYS:
+            raise ValueError("Key %s is not allowed. Only allowed"
+                             " keys are : 'id', 'name', 'key',"
+                             " 'value', 'uri'" % key)
+        if key == "creators":
+            if isinstance(value, self.ListOfCreators):
+                dict.__setitem__(self, key, value)
+            elif isinstance(value, list):
+                dict.__setitem__(self, key, self.ListOfCreators(value))
+            else:
+                raise TypeError("The passed format for creators is invalid")
+        elif key == "created":
+            if not isinstance(value, str):
+                raise TypeError("The date passed must be a string")
+            else:
+                validateDate(value)
+                dict.__setitem__(self, key, value)
+        elif key == "modified":
+            if isinstance(value, self.ModifiedHistory):
+                dict.__setitem__(self, key, value)
+            elif isinstance(value, list):
+                dict.__setitem__(self, key, self.ModifiedHistory(value))
+            else:
+                raise TypeError("The passed format for modification"
+                                " history is invalid")
 
-    @property
-    def created(self):
-        return self._created
+    def __delitem__(self, key):
+        dict.__delitem__(self, key)
 
-    @created.setter
-    def created(self, value):
-        if not isinstance(value, str):
-            raise TypeError("The date passed must be a string")
-        else:
-            validateDate(value)
-            self._created = value
+    def __iter__(self):
+        return dict.__iter__(self)
 
-    @property
-    def modified(self):
-        return self._modified
+    def __len__(self):
+        return dict.__len__(self)
 
-    @modified.setter
-    def modified(self, value):
-        self._modified = self.ModifiedHistory(value)
+    def __contains__(self, x):
+        return dict.__contains__(self, x)
 
     class ListOfCreators(list):
         """A list extension to store each creator's info

cobra/core/meta_data/keyValuePair.py

@@ -2,8 +2,6 @@
 
 from __future__ import absolute_import
 
-from cobra.core.object import Object
-
 
 class ListOfKeyValue(list):
     """A list extension to store key-value pairs

cobra/core/meta_data/metaData.py

@@ -7,7 +7,7 @@
 from cobra.core.meta_data.keyValuePair import ListOfKeyValue
 
 
-class MetaData:
+class MetaData(dict):
     """Class representation of the meta-data of the component.
     It is a combination of three classes i.e CVTerm, History
     and KeyValuePair class.
@@ -25,92 +25,100 @@ class MetaData:
 
     """
 
+    VALID_KEYS = ["sbo", "cvTerms", "history", "listofKeyValue"]
+
     def __init__(self, cvterm=None, history=None, listofKeyValue=None):
         # setting the cvterm
         if cvterm is None:
-            self._cvTerms = CVTerm()
+            dict.__setitem__(self, "cvTerms", CVTerm())
         elif isinstance(cvterm, CVTerm):
-            self._cvTerms = cvterm
+            dict.__setitem__(self, "cvTerms", cvterm)
         elif isinstance(cvterm, dict):
-            self._cvTerms = CVTerm(cvterm)
+            dict.__setitem__(self, "cvTerms", CVTerm(cvterm))
         else:
             raise TypeError("Invalid format passed for cvterm")
         # setting the history of the component
         if history is None:
-            self._history = History()
+            dict.__setitem__(self, "history", History())
         elif isinstance(history, History):
-            self._history = history
+            dict.__setitem__(self, "history", history)
         elif isinstance(history, dict):
-            if "creator" not in history:
-                history["creator"] = []
+            if "creators" not in history:
+                history["creators"] = []
             if "created" not in history:
                 history["created"] = None
             if "modified" not in history:
                 history["modified"] = []
-            self._history = History(history["creator"],
-                                    history["created"], history["modified"])
+            dict.__setitem__(self, "history", History(history["creators"],
+                                                      history["created"],
+                                                      history["modified"]))
         else:
             raise TypeError("Invalid format passed for history")
         # setting the list of key-value pair
         if listofKeyValue is not None:
             if isinstance(listofKeyValue, ListOfKeyValue):
-                self._listofKeyValue = listofKeyValue
+                dict.__setitem__(self, "listofKeyValue", listofKeyValue)
             elif isinstance(listofKeyValue, list):
-                self._listofKeyValue = ListOfKeyValue(listofKeyValue)
+                dict.__setitem__(self, "listofKeyValue",
+                                 ListOfKeyValue(listofKeyValue))
             else:
                 raise TypeError("Key value pairs must be passed in a list")
         else:
-            self._listofKeyValue = ListOfKeyValue()
+            dict.__setitem__(self, "listofKeyValue", ListOfKeyValue())
 
-    @property
-    def cvTerms(self):
-        return getattr(self, "_cvTerms", None)
+    def __getitem__(self, key):
+        if key not in self.VALID_KEYS:
+            raise ValueError("Key %s is not allowed. Only allowed "
+                             "keys are : 'sbo', 'cvTerms', 'history', "
+                             "'listofKeyValue'" % key)
+        return dict.__getitem__(self, key)
 
-    @cvTerms.setter
-    def cvTerms(self, value):
-        if value == self._cvTerms:
-            pass
-        elif isinstance(value, CVTerm):
-            self._cvTerms = value
-        elif isinstance(value, dict):
-            self._cvTerms = CVTerm(cvterm)
-        else:
-            raise TypeError("This passed format for cvterm is invalid")
+    def __setitem__(self, key, value):
+        """Restricting the keys and values that can be set.
+           Only allowed keys are : 'sbo', 'cvTerms', 'history',
+           'listofKeyValue'
+        """
+        if key not in self.VALID_KEYS:
+            raise ValueError("Key %s is not allowed. Only allowed "
+                             "keys are : 'sbo', 'cvTerms', 'history', "
+                             "'listofKeyValue'" % key)
+        if key == "cvTerms":
+            if isinstance(value, CVTerm):
+                dict.__setitem__(self, "cvTerms", value)
+            elif isinstance(value, dict):
+                dict.__setitem__(self, "cvTerms", CVTerm(value))
+            else:
+                raise TypeError("This passed format for cvterm is invalid")
+        elif key == "history":
+            if isinstance(history, History):
+                dict.__setitem__(self, "history", history)
+            elif isinstance(history, dict):
+                if "creators" not in history:
+                    history["creators"] = []
+                if "created" not in history:
+                    history["created"] = None
+                if "modified" not in history:
+                    history["modified"] = []
+                dict.__setitem__(self, "history", History(history["creators"],
+                                                          history["created"],
+                                                          history["modified"]))
+        elif key == "listofKeyValue":
+            if isinstance(listofKeyValue, ListOfKeyValue):
+                dict.__setitem__(self, "listofKeyValue", listofKeyValue)
+            elif isinstance(listofKeyValue, list):
+                dict.__setitem__(self, "listofKeyValue",
+                                 ListOfKeyValue(listofKeyValue))
+            else:
+                raise TypeError("Key value pairs must be passed in a list")
 
-    @property
-    def history(self):
-        return getattr(self, "_history", None)
+    def __delitem__(self, key):
+        dict.__delitem__(self, key)
 
-    @history.setter
-    def history(self, value):
-        if value == self._history:
-            pass
-        elif isinstance(value, History):
-            self._history = value
-        elif isinstance(value, dict):
-            if "creator" not in history:
-                history["creator"] = []
-            if "created" not in history:
-                history["created"] = None
-            if "modified" not in history:
-                history["modified"] = []
-            self._history = History(value["creator"],
-                                    value["created"], value["modified"])
-        else:
-            raise TypeError("This passed format for history is invalid")
+    def __iter__(self):
+        return dict.__iter__(self)
 
-    @property
-    def listofKeyValue(self):
-        return getattr(self, "_listofKeyValue", [])
+    def __len__(self):
+        return dict.__len__(self)
 
-    @listofKeyValue.setter
-    def listofKeyValue(self, value):
-        if value == self._listofKeyValue:
-            pass
-        elif isinstance(value, ListOfKeyValue):
-            self._listofKeyValue = value
-        elif isinstance(value, list):
-            self._listofKeyValue = ListOfKeyValue(value)
-        else:
-            raise TypeError("This passed format for listofKeyValue is "
-                            "invalid")
+    def __contains__(self, x):
+        return dict.__contains__(self, x)

cobra/core/object.py

@@ -3,7 +3,7 @@
 from __future__ import absolute_import
 
 from six import string_types
-
+from cobra.core.meta_data import MetaData
 
 class Object(object):
     """Defines common behavior of object in cobra.core"""
@@ -20,7 +20,7 @@ def __init__(self, id=None, name=""):
         self.name = name
 
         self.notes = {}
-        self._annotation = {}
+        self.annotation = MetaData()
 
     @property
     def id(self):
@@ -40,17 +40,6 @@ def id(self, value):
     def _set_id_with_model(self, value):
         self._id = value
 
-    @property
-    def annotation(self):
-        return self._annotation
-
-    @annotation.setter
-    def annotation(self, annotation):
-        if not isinstance(annotation, dict):
-            raise TypeError("Annotation must be a dict")
-        else:
-            self._annotation = annotation
-
     def __getstate__(self):
         """To prevent excessive replication during deepcopy."""
         state = self.__dict__.copy()