Refine the set_attributes API

Renamed to set_attributes from update_attributes, because "update"
implies that we're hitting the db (because of the UPDATE SQL command).
Set is much better for local attribute modification. This also uses the
set_attribute function when instantiating the model, so that we don't
take kwargs in the constructor (this was confusing me in the docs; what
were those kwargs supposed to be for? Am I supposed to supply them
somehow?). I factored out a check_registration function and fixed a
buggy check in Model.__init__ to use that.

Author: chadwhitacre

postgres/__init__.py

@@ -663,14 +663,29 @@ def unregister_model(self, ModelSubclass):
             unregister
         :raises: :py:exc:`~postgres.NotRegistered`
 
+        """
+        key = self.check_registration(ModelSubclass)
+        del self.model_registry[key]
+
+
+    def check_registration(self, ModelSubclass):
+        """Check whether an ORM model is registered.
+
+        :param ModelSubclass: the :py:class:`~postgres.orm.Model` subclass to
+            check for
+        :returns: the :py:attr:`typname` (a string) for which this model is
+            registered
+        :rettype: string
+        :raises: :py:exc:`~postgres.NotRegistered`
+
         """
         key = None
         for key, v in self.model_registry.items():
             if v is ModelSubclass:
                 break
         if key is None:
             raise NotRegistered(ModelSubclass)
-        del self.model_registry[key]
+        return key
 
 
 # Context Managers
@@ -875,7 +890,12 @@ def make(self, values):
                 raise NotImplementedError
 
             ModelSubclass = postgres.model_registry[self.name]
-            return ModelSubclass(**dict(zip(self.attnames, values)))
+
+            instance = ModelSubclass()
+            instance._set_read_only_attributes(self.attnames)
+            instance.set_attributes(**dict(zip(self.attnames, values)))
+
+            return instance
 
     return DelegatingCaster
 

postgres/orm.py

@@ -219,33 +219,31 @@ class Model(object):
     db = None                               # will be set to a Postgres object
     __read_only_attributes = []             # bootstrap
 
-    def __init__(self, **kw):
+    def __init__(self):
         if self.db is None:
             raise NotBound(self)
-        if self.db is None:
-            raise NotRegistered(self)
+        self.db.check_registration(self)
         self.__read_only_attributes = []    # overwrite class-level one
-        for k,v in kw.items():
-            self.__read_only_attributes.append(k)
-            self.__dict__[k] = v
 
     def __setattr__(self, name, value):
         if name in self.__read_only_attributes:
             raise ReadOnly(name)
         return super(Model, self).__setattr__(name, value)
 
-    def update_attributes(self, **kw):
-        """Update instance attributes, according to :py:attr:`kw`.
+    def _set_read_only_attributes(self, attribute_names):
+        self.__read_only_attributes = attribute_names
+
+    def set_attributes(self, **kw):
+        """Set instance attributes, according to :py:attr:`kw`.
 
         :raises: :py:exc:`~postgres.orm.UnknownAttributes`
 
         Call this when you update state in the database and you want to keep
-        instance attributes in sync. Note that the only attributes we can
-        update here are the ones that were given to us by the
-        :py:mod:`psycopg2` composite caster machinery when we were first
-        instantiated. These will be the fields of the composite type for which
-        we were registered, which will be column names for table and view
-        types.
+        instance attributes in sync. Note that the only attributes we can set
+        here are the ones that were given to us by the :py:mod:`psycopg2`
+        composite caster machinery when we were first instantiated. These will
+        be the fields of the composite type for which we were registered, which
+        will be column names for table and view types.
 
         """
         unknown = []

tests.py

@@ -232,7 +232,7 @@ def update_bar(self, bar):
             self.db.run( "UPDATE foo SET bar=%s WHERE bar=%s"
                        , (bar, self.bar)
                         )
-            self.update_attributes(bar=bar)
+            self.set_attributes(bar=bar)
 
     def setUp(self):
         WithData.setUp(self)