Ticket #277: pyamf_sqlalchemy_adapter.diff

THANKS.txt

@@ -3 +3 @@
 Joachim Bauch                  jojo@struktur.de
 Antti Kaihola                  akaihol+pyamf@ambitone.com
 Jacob Feisley                  jacob.feisley@gmail.com
+Michael van Tellingen          m.vantellingen@auto-interactive.nl
 
 And everyone who keeps sending feedback, helping us improve PyAMF.
+ No newline at end of file

pyamf/tests/adapters/test_sqlalchemy.py

@@ +1 @@
+# Copyright (c) 2007-2008 The PyAMF Project.
+# See LICENSE for details.
+
+"""
+PyAMF SQLAlchemy adapter tests.
+
+@since 0.4.0
+"""
+import datetime
+import sys
+import unittest
+
+import sqlalchemy
+from sqlalchemy import MetaData, Table, Column, Integer, String, ForeignKey, \
+                       create_engine 
+from sqlalchemy.orm import mapper, relation, sessionmaker
+
+import pyamf
+import pyamf.flex
+
+class SATestCase(unittest.TestCase):
+        
+    def test_model(self):
+        my_sa_user = self.User()
+        my_sa_user.name = "Test user"
+        self.session.save(my_sa_user)
+
+        my_user = self.User()
+        my_user.name = "Test user"
+        
+        self.session.commit()
+        
+        encoder = pyamf.get_encoder(pyamf.AMF3)
+        encoder.writeElement(my_user)
+        stream_value = encoder.stream.getvalue()
+        
+        encoder = pyamf.get_encoder(pyamf.AMF3)
+        encoder.writeElement(my_sa_user)                        
+        encoder.stream.getvalue()
+
+    def test_array_collection(self):
+        for i in range(0, 20):
+            my_user = self.User()
+            my_user.name = "Test user %d" % i
+            self.session.save(my_user)
+        
+        users = self.session.query(self.User).all()
+        
+        ac = pyamf.flex.ArrayCollection([user for user in users])
+
+        encoder = pyamf.get_encoder(pyamf.AMF3)
+        encoder.writeElement(ac)
+        encoder.stream.getvalue()
+
+    def test_complex_structure(self):
+        user = self.User(name="test-user")
+        user.addresses.append(self.Address(email_address="test@example.org"))
+        for i, string in enumerate(['one', 'two', 'three']):
+            addr = self.Address(email_address="%s@example.org" % string)
+            addr.info.append(self.AddressInfo(data="%s-%d" % (string, i)))
+            user.addresses.append(addr)
+        
+        encoder = pyamf.get_encoder(pyamf.AMF3)
+        encoder.writeElement(user)
+        data = encoder.stream.getvalue()
+
+        expected_data = (
+            '\n\x0b\x01\tname\x06\x13test-user\x13addresses\t\t\x01\n\x0b\x01'
+            '\x1bemail_address\x06!test@example.org\tuser\n\x00\x01\n\x0b\x01'
+            '\tinfo\t\x03\x01\n\x0b\x01\tdata\x06\x0bone-0\x0faddress\n\x06'
+            '\x01\x06\x06\x1fone@example.org\n\n\x00\x01\n\x0b\x01\x0c\t\x03'
+            '\x01\n\x0b\x01\x0e\x06\x0btwo-1\x12\n\x0c\x01\x06\x06\x1ftwo@examp'
+            'le.org\n\n\x00\x01\n\x0b\x01\x0c\t\x03\x01\n\x0b\x01\x0e\x06\x0fth'
+            'ree-2\x12\n\x12\x01\x06\x06#three@example.org\n\n\x00\x01\x01')
+        
+        self.assertEqual(data, expected_data)
+        
+        
+    def setUp(self):
+        metadata = MetaData()
+        engine = create_engine('sqlite:///:memory:', echo=False)
+        
+        Session = sessionmaker(bind=engine)
+        
+        self.session = Session()
+        
+        users_table = Table('users_table', metadata,
+                        Column('id', Integer, primary_key=True),
+                        Column('name', String(64)))
+
+        addresses_table = Table('addresses_table', metadata,
+                            Column('id', Integer, primary_key=True),
+                            Column('user_id', Integer,
+                                   ForeignKey('users_table.id')),
+                            Column('email_address', String(128)))
+
+        address_information = Table('addrinfo_table', metadata,
+                                Column('id', Integer, primary_key=True),
+                                Column('addr_id', Integer,
+                                       ForeignKey('addresses_table.id')),
+                                Column('data', String(128)))
+        
+                                
+        mapper(self.User, users_table, properties=dict(
+               addresses=relation(self.Address, backref='user'),
+               ))
+      
+        mapper(self.Address, addresses_table, properties=dict(
+                info=relation(self.AddressInfo, backref='address'),
+                ))
+        
+        mapper(self.AddressInfo, address_information)
+        
+        metadata.create_all(engine)
+        
+        
+    def tearDown(self):
+        from sqlalchemy.orm import clear_mappers
+        clear_mappers()
+            
+
+    class User(object):
+        def __init__(self, **kwargs):
+            self.__dict__.update(kwargs)
+
+    class Address(object):
+        def __init__(self, **kwargs):
+            self.__dict__.update(kwargs)
+
+    class AddressInfo(object):
+        def __init__(self, **kwargs):
+            self.__dict__.update(kwargs)
+
+            
+def suite():
+    suite = unittest.TestSuite()
+
+    suite.addTest(unittest.makeSuite(SATestCase))
+
+    return suite
+
+if __name__ == '__main__':
+    unittest.main(defaultTest='suite')
+ No newline at end of file

pyamf/adapters/_sqlalchemy.py

@@ +1 @@
+# Copyright (c) 2007-2008 The PyAMF Project.
+# See LICENSE for details.
+
+"""
+SQLAlchemy adapter (experimental!)
+
+@since: 0.4.0
+"""
+import copy
+
+import sqlalchemy
+import sqlalchemy.orm.session
+
+import pyamf
+
+def writeSAObject(obj):
+    """
+    Return a copy of the given sqlalchemy orm object.
+    """
+    base_obj = obj
+    
+    # Create a copy of the object
+    obj = copy.copy(obj)
+    
+    # Collect properties which are not 'known'
+    properties = [property for property in obj.__dict__
+                    if property not in getattr(obj, 'c', []) and
+                       property != "_sa_session_id"]
+    
+    # Iterate over the properties which are not columns of the orm mapped table
+    for property in properties:
+        # Delete 'private' properties
+        if property.startswith('_'):
+            del obj.__dict__[property]
+            continue
+        
+        # one-to-many references are stored in the InstrumentedList type
+        # convert it to a list and search properties of each item to update the
+        # backrefence of the object to the copied object
+        value = obj.__dict__[property]
+        if isinstance(value, sqlalchemy.orm.collections.InstrumentedList):
+            value = list(value)
+
+            # Update backreferences to the copied object
+            for item in value:
+                for item_property in item.__dict__:
+                    if item.__dict__[item_property] == base_obj:
+                        item.__dict__[item_property] = obj
+            
+            obj.__dict__[property] = value
+    return obj
+
+def isSqlAlchemyObject(data):
+    """ Detect if this object is registered in a sqlalchemy session.
+        sqlalchemy 0.4 created a private variable '_state' in the object to
+        store state information. in sqlalchemy 0.5 this is '_sa_instance_state'
+    """
+    if not isinstance(data, object):
+        return False
+    
+    # sqlalchemy 0.4 detection    
+    state = getattr(data, '_state', None)
+    
+    # sqlalchemy 0.5 ?
+    if not state:
+        state = getattr(data, '_sa_instance_state', None)
+        
+    return isinstance(state, sqlalchemy.orm.attributes.InstanceState)
+
+pyamf.add_type(isSqlAlchemyObject, writeSAObject)

pyamf/__init__.py

@@ -595 +595 @@
         except AttributeError:
             return self._getWriteElementFunc(data)
 
+        func = self._getWriteElementFunc(data)
+        
+        # Don't cache CustomTypeFunc objects!
+        if isinstance(func, CustomTypeFunc):
+            return func
+        
         if key not in self._write_elem_func_cache:
-            self._write_elem_func_cache[key] =  self._getWriteElementFunc(data)
+            self._write_elem_func_cache[key] =  func
 
         return self._write_elem_func_cache[key]
 

pyamf/amf3.py

@@ -1238 +1238 @@
                     func(data, use_references=use_references)
             except (KeyboardInterrupt, SystemExit):
                 raise
-            except:
+            except Exception, e:
                 raise pyamf.EncodeError, "Unable to encode '%r'" % data
 
     def writeType(self, type):
@@ -1409 +1409 @@
         @param  use_references:
         """
         self.writeType(ASTypes.ARRAY)
-
+        
         if use_references is True:
             try:
                 ref = self.context.getObjectReference(n)