Pass record to Model constructor

Previously we had no explicit Model constructor, and we were preparing
the object by futzing with it in the delegating caster machinery. That
allowed a user to implement their own constructor, though since it
didn't receive any arguments it would have been of limited utility. Now
a user can receive the raw query result in their Model subclass
constructor (or __new__, which is actually what I want that's driving
this).

Author: chadwhitacre

postgres/__init__.py

@@ -782,11 +782,8 @@ def make(self, values):
                 raise NotImplementedError
 
             ModelSubclass = postgres.model_registry[self.name]
-
-            instance = ModelSubclass()
-            instance._set_read_only_attributes(self.attnames)
-            instance.set_attributes(**dict(zip(self.attnames, values)))
-
+            record = dict(zip(self.attnames, values))
+            instance = ModelSubclass(record)
             return instance
 
     return DelegatingCaster

postgres/orm.py

@@ -202,15 +202,16 @@ def __str__(self):
 # =====
 
 class Model(object):
-    """
+    """This is the base class for models in :py:mod:`postgres.orm`.
+
+    :param dict record: The raw query result
 
-    This is the base class for models in :py:mod:`postgres.orm`. Instances of
-    subclasses of :py:class:`~postgres.orm.Model` will have an attribute for
-    each field in the composite type for which the subclass is registered (for
-    table and view types, these will be the columns of the table or view).
-    These attributes are read-only. We don't update your database. You are
-    expected to do that yourself in methods on your subclass. To keep instance
-    attributes in sync after a database update, use the
+    Instances of subclasses of :py:class:`~postgres.orm.Model` will have an
+    attribute for each field in the composite type for which the subclass is
+    registered (for table and view types, these will be the columns of the
+    table or view).  These attributes are read-only. We don't update your
+    database. You are expected to do that yourself in methods on your subclass.
+    To keep instance attributes in sync after a database update, use the
     :py:meth:`~postgres.orm.Model.set_attributes` helper.
 
     """
@@ -219,20 +220,18 @@ class Model(object):
     db = None                               # will be set to a Postgres object
     __read_only_attributes = []             # bootstrap
 
-    def __init__(self):
+    def __init__(self, record):
         if self.db is None:
             raise NotBound(self)
         self.db.check_registration(self)
-        self.__read_only_attributes = []    # overwrite class-level one
+        self.__read_only_attributes = record.keys()
+        self.set_attributes(**record)
 
     def __setattr__(self, name, value):
         if name in self.__read_only_attributes:
             raise ReadOnly(name)
         return super(Model, self).__setattr__(name, value)
 
-    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`.
 

tests.py

@@ -228,6 +228,11 @@ class MyModel(Model):
 
         typname = "foo"
 
+        def __init__(self, record):
+            from postgres.orm import Model
+            Model.__init__(self, record)
+            self.bar_from_init = record['bar']
+
         def update_bar(self, bar):
             self.db.run( "UPDATE foo SET bar=%s WHERE bar=%s"
                        , (bar, self.bar)
@@ -245,6 +250,10 @@ def test_orm_basically_works(self):
         one = self.db.one("SELECT foo.*::foo FROM foo WHERE bar='baz'")
         assert one.__class__ == self.MyModel
 
+    def test_orm_models_get_kwargs_to_init(self):
+        one = self.db.one("SELECT foo.*::foo FROM foo WHERE bar='baz'")
+        assert one.bar_from_init == 'baz'
+
     def test_updating_attributes_works(self):
         one = self.db.one("SELECT foo.*::foo FROM foo WHERE bar='baz'")
         one.update_bar("blah")