Managers: attempt to extract trans from de/serializers

lib/galaxy/managers/annotatable.py

@@ -29,7 +29,7 @@ class AnnotatableManagerMixin( object ):
         annotation_obj = item.add_item_annotation( self.session(), user, item, annotation )
         return annotation_obj.annotation
 
-    #def by_user( self, trans, user, **kwargs ):
+    #def by_user( self, user, **kwargs ):
     #    pass
 
 
@@ -38,13 +38,11 @@ class AnnotatableSerializerMixin( object ):
     def add_serializers( self ):
         self.serializers[ 'annotation' ] = self.serialize_annotation
 
-    def serialize_annotation( self, trans, item, key ):
+    def serialize_annotation( self, item, key, user=None, **context ):
         """
         Get and serialize an `item`'s annotation.
         """
         # user = item.user
-        #TODO: trans
-        user = trans.user
         sa_session = self.app.model.context
         returned = item.get_item_annotation_str( sa_session, user, item )
         return returned
@@ -55,22 +53,25 @@ class AnnotatableDeserializerMixin( object ):
     def add_deserializers( self ):
         self.deserializers[ 'annotation' ] = self.deserialize_annotation
 
-    def deserialize_annotation( self, trans, item, key, val ):
+    def deserialize_annotation( self, item, key, val, user=None, **context ):
         """
         Make sure `val` is a valid annotation and assign it, deleting any existing
         if `val` is None.
         """
+        print '-' * 20
+        print item
+        print key
+        print val
+        print user
         val = self.validate.nullable_basestring( key, val )
+        # sa_session = self.app.model.context
+        # if val is None:
+        #     item.delete_item_annotation( sa_session, user, item )
+        #     return None
 
-        sa_session = self.app.model.context
-        #TODO: trans
-        user = trans.user
-        if val is None:
-            item.delete_item_annotation( sa_session, user, item )
-            return None
-
-        annotated_item = item.add_item_annotation( sa_session, user, item, val )
-        return annotated_item.annotation
+        # annotated_item = item.add_item_annotation( sa_session, user, item, val )
+        # return annotated_item.annotation
+        return self.manager.annotate( item, user, val )
 
 
 # TODO: I'm not entirely convinced this (or tags) are a good idea for filters since they involve a/the user

lib/galaxy/managers/base.py

@@ -500,7 +500,7 @@ class ModelSerializer( object ):
 
     Maintains a map of requestable keys and the Callable() serializer functions
     that should be called for those keys.
-    E.g. { 'x' : lambda trans, item, key: item.x, ... }
+    E.g. { 'x' : lambda item, key: item.x, ... }
 
     Note: if a key to serialize is not listed in the Serializer.serializable_keyset
     or serializers, it will not be returned.
@@ -509,7 +509,7 @@ class ModelSerializer( object ):
         my_serializer = MySerializer( app )
         ...
         keys_to_serialize = [ 'id', 'name', 'attr1', 'attr2', ... ]
-        item_dict = MySerializer.serialize( trans, my_item, keys_to_serialize )
+        item_dict = MySerializer.serialize( my_item, keys_to_serialize )
     """
     #: 'service' to use for getting urls - use class var to allow overriding when testing
     url_for = staticmethod( routes.url_for )
@@ -559,7 +559,7 @@ class ModelSerializer( object ):
         self.serializable_keyset.update( key_list )
         return key_list
 
-    def serialize( self, trans, item, keys ):
+    def serialize( self, item, keys, **context ):
         """
         Serialize the model `item` to a dictionary.
 
@@ -567,18 +567,18 @@ class ModelSerializer( object ):
         built from each key in `keys` that also exists in `serializers` and
         values of calling the keyed/named serializers on item.
         """
-        # main interface fn for converting a model to a dict
+        # TODO: constrain context to current_user/whos_asking when that's all we need (trans)
         returned = {}
         for key in keys:
             # check both serializers and serializable keys
             if key in self.serializers:
                 try:
-                    returned[ key ] = self.serializers[ key ]( trans, item, key )
+                    returned[ key ] = self.serializers[ key ]( item, key, **context )
                 except SkipAttribute, skip:
                     # dont add this key if the deserializer threw this
                     pass
             elif key in self.serializable_keyset:
-                returned[ key ] = self.default_serializer( trans, item, key )
+                returned[ key ] = self.default_serializer( item, key, **context )
             # ignore bad/unreg keys
         return returned
 
@@ -594,10 +594,10 @@ class ModelSerializer( object ):
         if original_key in self.serializers:
             return self.serializers[ original_key ]
         if original_key in self.serializable_keyset:
-            return lambda t, i, k: self.default_serializer( t, i, original_key )
+            return lambda i, k, **c: self.default_serializer( i, original_key, **c )
         raise KeyError( 'serializer not found for remap: ' + original_key )
 
-    def default_serializer( self, trans, item, key ):
+    def default_serializer( self, item, key, **context ):
         """
         Serialize the `item`'s attribute named `key`.
         """
@@ -605,14 +605,14 @@ class ModelSerializer( object ):
         return getattr( item, key )
 
     # serializers for common galaxy objects
-    def serialize_date( self, trans, item, key ):
+    def serialize_date( self, item, key, **context ):
         """
         Serialize a date attribute of `item`.
         """
         date = getattr( item, key )
         return date.isoformat() if date is not None else None
 
-    def serialize_id( self, trans, item, key ):
+    def serialize_id( self, item, key, **context ):
         """
         Serialize an id attribute of `item`.
         """
@@ -621,7 +621,7 @@ class ModelSerializer( object ):
         return self.app.security.encode_id( id ) if id is not None else None
 
     # serializing to a view where a view is a predefied list of keys to serialize
-    def serialize_to_view( self, trans, item, view=None, keys=None, default_view=None ):
+    def serialize_to_view( self, item, view=None, keys=None, default_view=None, **context ):
         """
         Use a predefined list of keys (the string `view`) and any additional keys
         listed in `keys`.
@@ -647,7 +647,7 @@ class ModelSerializer( object ):
             elif default_view:
                 all_keys = self._view_to_keys( default_view )
 
-        return self.serialize( trans, item, all_keys )
+        return self.serialize( item, all_keys, **context )
 
     def _view_to_keys( self, view=None ):
         """
@@ -697,16 +697,17 @@ class ModelDeserializer( object ):
         # to be overridden in subclasses
         pass
 
-    def deserialize( self, trans, item, data, flush=True ):
+    def deserialize( self, item, data, flush=True, **context ):
         """
         Convert an incoming serialized dict into values that can be
         directly assigned to an item's attributes and assign them
         """
+        # TODO: constrain context to current_user/whos_asking when that's all we need (trans)
         sa_session = self.app.model.context
         new_dict = {}
         for key, val in data.items():
             if key in self.deserializers:
-                new_dict[ key ] = self.deserializers[ key ]( trans, item, key, val )
+                new_dict[ key ] = self.deserializers[ key ]( item, key, val, **context )
             # !important: don't error on unreg. keys -- many clients will add weird ass keys onto the model
 
         # TODO:?? add and flush here or in manager?
@@ -717,7 +718,7 @@ class ModelDeserializer( object ):
         return new_dict
 
     # ... common deserializers for primitives
-    def default_deserializer( self, trans, item, key, val ):
+    def default_deserializer( self, item, key, val, **context ):
         """
         If the incoming `val` is different than the `item` value change it
         and, in either case, return the value.
@@ -729,28 +730,28 @@ class ModelDeserializer( object ):
             setattr( item, key, val )
         return val
 
-    def deserialize_basestring( self, trans, item, key, val ):
+    def deserialize_basestring( self, item, key, val, **context ):
         val = self.validate.basestring( key, val )
-        return self.default_deserializer( trans, item, key, val )
+        return self.default_deserializer( item, key, val, **context )
 
-    def deserialize_bool( self, trans, item, key, val ):
+    def deserialize_bool( self, item, key, val, **context ):
         val = self.validate.bool( key, val )
-        return self.default_deserializer( trans, item, key, val )
+        return self.default_deserializer( item, key, val, **context )
 
-    def deserialize_int( self, trans, item, key, val, min=None, max=None ):
+    def deserialize_int( self, item, key, val, min=None, max=None, **context ):
         val = self.validate.int_range( key, val, min, max )
-        return self.default_deserializer( trans, item, key, val )
+        return self.default_deserializer( item, key, val, **context )
 
-    #def deserialize_date( self, trans, item, key, val ):
+    #def deserialize_date( self, item, key, val ):
     #   #TODO: parse isoformat date into date object
 
     # ... common deserializers for Galaxy
-    def deserialize_genome_build( self, trans, item, key, val ):
+    def deserialize_genome_build( self, item, key, val, **context ):
         """
         Make sure `val` is a valid dbkey and assign it.
         """
         val = self.validate.genome_build( key, val )
-        return self.default_deserializer( trans, item, key, val )
+        return self.default_deserializer( item, key, val, **context )
 
 
 class ModelValidator( object ):
@@ -830,7 +831,7 @@ class ModelValidator( object ):
         # IOW: fallback to string validation
         return self.basestring( key, val )
 
-    # def slug( self, trans, item, key, val ):
+    # def slug( self, item, key, val ):
     #    """validate slug"""
     #    pass
 

lib/galaxy/managers/configuration.py

@@ -15,6 +15,7 @@ import logging
 log = logging.getLogger( __name__ )
 
 
+#TODO: for lack of a manager file for the config. May well be better in config.py? Circ imports?
 class ConfigSerializer( base.ModelSerializer ):
 
     def __init__( self, app ):
@@ -23,61 +24,64 @@ class ConfigSerializer( base.ModelSerializer ):
         self.default_view = 'all'
         self.add_view( 'all', self.serializers.keys() )
 
-    def default_serializer( self, trans, config, key ):
-        return config.get( key, None )
-
-    def _defaults_to( self, default ):
-        return lambda t, i, k: i.get( k, default )
+    def default_serializer( self, config, key ):
+        return getattr( config, key, None )
 
     def add_serializers( self ):
+        def _defaults_to( default ):
+            return lambda i, k, **c: getattr( i, k, default )
+
         self.serializers = {
             #TODO: this is available from user data, remove
-            'is_admin_user'             : lambda *a: False,
+            'is_admin_user'             : lambda *a, **c: False,
 
-            'brand'                     : lambda t, i, k: i.get( k, "" ),
+            'brand'                     : _defaults_to( '' ),
             #TODO: this doesn't seem right
-            'logo_url'                  : lambda t, i, k: web.url_for( i.get( k, '/') ),
-            'terms_url'                 : lambda t, i, k: i.get( k, "" ),
+            'logo_url'                  : lambda i, k, **c: self.url_for( i.get( k, '/' ) ),
+            'terms_url'                 : _defaults_to( '' ),
 
             #TODO: don't hardcode here - hardcode defaults once in config.py
-            'wiki_url'                  : self._defaults_to( "http://galaxyproject.org/" ),
-            'search_url'                : self._defaults_to( "http://galaxyproject.org/search/usegalaxy/" ),
-            'mailing_lists'             : self._defaults_to( "http://wiki.galaxyproject.org/MailingLists" ),
-            'screencasts_url'           : self._defaults_to( "http://vimeo.com/galaxyproject" ),
-            'citation_url'              : self._defaults_to( "http://wiki.galaxyproject.org/CitingGalaxy" ),
-            'support_url'               : self._defaults_to( "http://wiki.galaxyproject.org/Support" ),
-            'lims_doc_url'              : self._defaults_to( "http://main.g2.bx.psu.edu/u/rkchak/p/sts" ),
-            'biostar_url'               : lambda t, i, k: i.biostar_url,
-            'biostar_url_redirect'      : lambda *a: web.url_for( controller='biostar', action='biostar_redirect',
-                                                                qualified=True ),
+            'wiki_url'                  : _defaults_to( "http://galaxyproject.org/" ),
+            'search_url'                : _defaults_to( "http://galaxyproject.org/search/usegalaxy/" ),
+            'mailing_lists'             : _defaults_to( "http://wiki.galaxyproject.org/MailingLists" ),
+            'screencasts_url'           : _defaults_to( "http://vimeo.com/galaxyproject" ),
+            'citation_url'              : _defaults_to( "http://wiki.galaxyproject.org/CitingGalaxy" ),
+            'support_url'               : _defaults_to( "http://wiki.galaxyproject.org/Support" ),
+            'lims_doc_url'              : _defaults_to( "http://main.g2.bx.psu.edu/u/rkchak/p/sts" ),
+            'biostar_url'               : _defaults_to( '' ),
+            'biostar_url_redirect'      : lambda *a, **c: self.url_for( controller='biostar', action='biostar_redirect',
+                                                                   qualified=True ),
 
-            'allow_user_creation'       : lambda t, i, k: i.allow_user_creation,
-            'use_remote_user'           : lambda t, i, k: i.use_remote_user,
-            'remote_user_logout_href'   : lambda t, i, k: i.remote_user_logout_href,
-            'enable_cloud_launch'       : self._defaults_to( False ),
-            'datatypes_disable_auto'    : self._defaults_to( False ),
-            'allow_user_dataset_purge'  : self._defaults_to( False ),
-            'enable_unique_workflow_defaults' : self._defaults_to( False ),
+            'allow_user_creation'       : lambda i, k, **c: i.allow_user_creation,
+            'use_remote_user'           : _defaults_to( None ),
+            'remote_user_logout_href'   : _defaults_to( '' ),
+            'enable_cloud_launch'       : _defaults_to( False ),
+            'datatypes_disable_auto'    : _defaults_to( False ),
+            'allow_user_dataset_purge'  : _defaults_to( False ),
+            'enable_unique_workflow_defaults' : _defaults_to( False ),
 
-            'nginx_upload_path'         : self._defaults_to( web.url_for( controller='api', action='tools' ) ),
-            'ftp_upload_dir'            : self._defaults_to( None ),
-            'ftp_upload_site'           : self._defaults_to( None ),
+            'nginx_upload_path'         : _defaults_to( self.url_for( controller='api', action='tools' ) ),
+            'ftp_upload_dir'            : _defaults_to( None ),
+            'ftp_upload_site'           : _defaults_to( None ),
+            'version_major'             : _defaults_to( None ),
         }
 
 
 class AdminConfigSerializer( ConfigSerializer ):
-    """Config attributes viewable by admin users"""
+    # config attributes viewable by admin users
 
     def add_serializers( self ):
         super( AdminConfigSerializer, self ).add_serializers()
+        def _defaults_to( default ):
+            return lambda i, k, **c: getattr( i, k, default )
 
         self.serializers.update({
             #TODO: this is available from user data, remove
             'is_admin_user'             : lambda *a: True,
 
-            'library_import_dir'        : self._defaults_to( None ),
-            'user_library_import_dir'   : self._defaults_to( None ),
-            'allow_library_path_paste'  : self._defaults_to( None ),
-            'allow_user_creation'       : self._defaults_to( False ),
-            'allow_user_deletion'       : self._defaults_to( False ),
+            'library_import_dir'        : _defaults_to( None ),
+            'user_library_import_dir'   : _defaults_to( None ),
+            'allow_library_path_paste'  : _defaults_to( False ),
+            'allow_user_creation'       : _defaults_to( False ),
+            'allow_user_deletion'       : _defaults_to( False ),
         })

lib/galaxy/managers/datasets.py

@@ -111,6 +111,7 @@ class DatasetRBACPermissions( object ):
     def available_roles( self, trans, dataset, controller='root' ):
         return self.app.security_agent.get_legitimate_roles( trans, dataset, controller )
 
+    # TODO: not enough by a long shot
     def get( self, dataset, flush=True ):
         manage = self.manage.by_dataset( dataset )
         access = self.access.by_dataset( dataset )
@@ -121,6 +122,7 @@ class DatasetRBACPermissions( object ):
         access = self.access.set( dataset, access_roles or [], flush=flush )
         return ( manage, access )
 
+    # ---- conv. settings
     def set_public_with_single_manager( self, dataset, user, flush=True ):
         manage = self.manage.grant( dataset, user, flush=flush )
         access = self.access.clear( dataset, flush=False )
@@ -164,16 +166,16 @@ class DatasetSerializer( base.ModelSerializer, deletable.PurgableSerializerMixin
             'create_time'   : self.serialize_date,
             'update_time'   : self.serialize_date,
 
-            'uuid'          : lambda t, i, k: str( i.uuid ) if i.uuid else None,
+            'uuid'          : lambda i, k, **c: str( i.uuid ) if i.uuid else None,
             'file_name'     : self.serialize_file_name,
             'extra_files_path' : self.serialize_extra_files_path,
             'permissions'   : self.serialize_permissions,
 
-            'total_size'    : lambda t, i, k: int( i.get_total_size() ),
-            'file_size'     : lambda t, i, k: int( i.get_size() )
+            'total_size'    : lambda i, k, **c: int( i.get_total_size() ),
+            'file_size'     : lambda i, k, **c: int( i.get_size() )
         })
 
-    def serialize_file_name( self, trans, dataset, key ):
+    def serialize_file_name( self, dataset, key, **context ):
         """
         If the config allows or the user is admin, return the file name
         of the file that contains this dataset's data.
@@ -184,7 +186,7 @@ class DatasetSerializer( base.ModelSerializer, deletable.PurgableSerializerMixin
             self.skip()
         return dataset.file_name
 
-    def serialize_extra_files_path( self, trans, dataset, key ):
+    def serialize_extra_files_path( self, dataset, key, **context ):
         """
         If the config allows or the user is admin, return the file path.
         """
@@ -194,7 +196,7 @@ class DatasetSerializer( base.ModelSerializer, deletable.PurgableSerializerMixin
             self.skip()
         return dataset.extra_files_path
 
-    def serialize_permissions( self, trans, dataset, key ):
+    def serialize_permissions( self, dataset, key, **context ):
         """
         """
         permissions = {}
@@ -214,7 +216,7 @@ class DatasetDeserializer( base.ModelDeserializer, deletable.PurgableDeserialize
             'permissions' : self.deserialize_permissions,
         })
 
-    def deserialize_permissions( self, trans, dataset, key, value ):
+    def deserialize_permissions( self, dataset, key, value, **context ):
         """
         """
         permissions = {}
@@ -322,7 +324,7 @@ class _UnflattenedMetadataDatasetAssociationSerializer( base.ModelSerializer,
             'update_time'   : self.serialize_date,
 
             # underlying dataset
-            'dataset'       : lambda t, i, k: self.dataset_serializer.serialize_to_view( t, i.dataset, view='summary' ),
+            'dataset'       : lambda i, k, **c: self.dataset_serializer.serialize_to_view( i.dataset, view='summary', **c ),
             'dataset_id'    : self._proxy_to_dataset( key='id' ),
             #TODO: why is this named uuid!? The da doesn't have a uuid - it's the underlying dataset's uuid!
             'uuid'          : self._proxy_to_dataset( key='uuid' ),
@@ -331,31 +333,31 @@ class _UnflattenedMetadataDatasetAssociationSerializer( base.ModelSerializer,
             'extra_files_path' : self._proxy_to_dataset( serializer=self.dataset_serializer.serialize_extra_files_path ),
             'permissions'   : self._proxy_to_dataset( serializer=self.dataset_serializer.serialize_permissions),
             # TODO: do the sizes proxy accurately/in the same way?
-            'size'          : lambda t, i, k: int( i.get_size() ),
-            'file_size'     : lambda t, i, k: self.serializers[ 'size' ]( t, i, k ),
-            'nice_size'     : lambda t, i, k: i.get_size( nice_size=True ),
+            'size'          : lambda i, k, **c: int( i.get_size() ),
+            'file_size'     : lambda i, k, **c: self.serializers[ 'size' ]( i, k, **c ),
+            'nice_size'     : lambda i, k, **c: i.get_size( nice_size=True ),
 
             # common to lddas and hdas - from mapping.py
             'copied_from_history_dataset_association_id'        : self.serialize_id,
             'copied_from_library_dataset_dataset_association_id': self.serialize_id,
-            'info'          : lambda t, i, k: i.info.strip() if isinstance( i.info, basestring ) else i.info,
-            'blurb'         : lambda t, i, k: i.blurb,
-            'peek'          : lambda t, i, k: i.display_peek() if i.peek and i.peek != 'no peek' else None,
+            'info'          : lambda i, k, **c: i.info.strip() if isinstance( i.info, basestring ) else i.info,
+            'blurb'         : lambda i, k, **c: i.blurb,
+            'peek'          : lambda i, k, **c: i.display_peek() if i.peek and i.peek != 'no peek' else None,
 
             'meta_files'    : self.serialize_meta_files,
             'metadata'      : self.serialize_metadata,
 
             'parent_id'     : self.serialize_id,
-            'designation'   : lambda t, i, k: i.designation,
+            'designation'   : lambda i, k, **c: i.designation,
 
             # 'extended_metadata'     : self.serialize_extended_metadata,
             # 'extended_metadata_id'  : self.serialize_id,
 
             # remapped
-            'genome_build'  : lambda t, i, k: i.dbkey,
+            'genome_build'  : lambda i, k, **c: i.dbkey,
 
             # derived (not mapped) attributes
-            'data_type'     : lambda t, i, k: i.datatype.__class__.__module__ + '.' + i.datatype.__class__.__name__,
+            'data_type'     : lambda i, k, **c: i.datatype.__class__.__module__ + '.' + i.datatype.__class__.__name__,
 
             # TODO: conversions
             # TODO: metadata/extra files
@@ -368,10 +370,10 @@ class _UnflattenedMetadataDatasetAssociationSerializer( base.ModelSerializer,
         if key:
             serializer = self.dataset_serializer.serializers.get( key )
         if serializer:
-            return lambda t, i, k: serializer( t, i.dataset, key or k )
+            return lambda i, k, **c: serializer( i.dataset, key or k, **c )
         raise TypeError( 'kwarg serializer or key needed')
 
-    def serialize_meta_files( self, trans, dataset_assoc, key ):
+    def serialize_meta_files( self, dataset_assoc, key, **context ):
         """
         Cycle through meta files and return them as a list of dictionaries.
         """
@@ -381,7 +383,7 @@ class _UnflattenedMetadataDatasetAssociationSerializer( base.ModelSerializer,
                 meta_files.append( dict( file_type=meta_type ) )
         return meta_files
 
-    def serialize_metadata( self, trans, dataset_assoc, key, excluded=None ):
+    def serialize_metadata( self, dataset_assoc, key, excluded=None, **context ):
         """
         Cycle through metadata and return as dictionary.
         """
@@ -417,7 +419,7 @@ class DatasetAssociationSerializer( _UnflattenedMetadataDatasetAssociationSerial
         # remove the single nesting key here
         del self.serializers[ 'metadata' ]
 
-    def serialize( self, trans, dataset_assoc, keys ):
+    def serialize( self, dataset_assoc, keys, **context ):
         """
         Override to add metadata as flattened keys on the serialized DatasetInstance.
         """
@@ -425,11 +427,11 @@ class DatasetAssociationSerializer( _UnflattenedMetadataDatasetAssociationSerial
         # TODO: remove these when metadata is sub-object
         KEYS_HANDLED_SEPARATELY = ( 'metadata', )
         left_to_handle = self._pluck_from_list( keys, KEYS_HANDLED_SEPARATELY )
-        serialized = super( DatasetAssociationSerializer, self ).serialize( trans, dataset_assoc, keys )
+        serialized = super( DatasetAssociationSerializer, self ).serialize( dataset_assoc, keys, **context )
 
         # add metadata directly to the dict instead of as a sub-object
         if 'metadata' in left_to_handle:
-            metadata = self._prefixed_metadata( trans, dataset_assoc )
+            metadata = self._prefixed_metadata( dataset_assoc )
             serialized.update( metadata )
         return serialized
 
@@ -447,13 +449,13 @@ class DatasetAssociationSerializer( _UnflattenedMetadataDatasetAssociationSerial
                 pass
         return found
 
-    def _prefixed_metadata( self, trans, dataset_assoc ):
+    def _prefixed_metadata( self, dataset_assoc ):
         """
         Adds (a prefixed version of) the DatasetInstance metadata to the dict,
         prefixing each key with 'metadata_'.
         """
         # build the original, nested dictionary
-        metadata = self.serialize_metadata( trans, dataset_assoc, 'metadata' )
+        metadata = self.serialize_metadata( dataset_assoc, 'metadata' )
 
         # prefix each key within and return
         prefixed = {}
@@ -475,16 +477,17 @@ class DatasetAssociationDeserializer( base.ModelDeserializer, deletable.Purgable
         })
         self.deserializable_keyset.update( self.deserializers.keys() )
 
-    def deserialize_metadata( self, trans, dataset_assoc, metadata_key, metadata_dict ):
+# TODO: untested
+    def deserialize_metadata( self, dataset_assoc, metadata_key, metadata_dict, **context ):
         """
         """
         self.validate.type( metadata_key, metadata_dict, dict )
         returned = {}
         for key, val in metadata_dict.items():
-            returned[ key ] = self.deserialize_metadatum( trans, dataset_assoc, key, val )
+            returned[ key ] = self.deserialize_metadatum( dataset_assoc, key, val, **context )
         return returned
 
-    def deserialize_metadatum( self, trans, dataset_assoc, key, val ):
+    def deserialize_metadatum( self, dataset_assoc, key, val, **context ):
         """
         """
         if key not in dataset_assoc.datatype.metadata_spec:

lib/galaxy/managers/deletable.py

@@ -18,7 +18,6 @@ class DeletableManagerMixin( object ):
     that they are no longer needed, should not be displayed, or may be actually
     removed by an admin/script.
     """
-
     def delete( self, item, flush=True, **kwargs ):
         """
         Mark as deleted and return.
@@ -44,7 +43,7 @@ class DeletableDeserializerMixin( object ):
     def add_deserializers( self ):
         self.deserializers[ 'deleted' ] = self.deserialize_deleted
 
-    def deserialize_deleted( self, trans, item, key, val ):
+    def deserialize_deleted( self, item, key, val, **context ):
         """
         Delete or undelete `item` based on `val` then return `item.deleted`.
         """
@@ -73,7 +72,6 @@ class PurgableManagerMixin( DeletableManagerMixin ):
     purging is often removal of some additional, non-db resource (e.g. a dataset's
     file).
     """
-
     def purge( self, item, flush=True, **kwargs ):
         """
         Mark as purged and return.
@@ -96,7 +94,7 @@ class PurgableDeserializerMixin( DeletableDeserializerMixin ):
         DeletableDeserializerMixin.add_deserializers( self )
         self.deserializers[ 'purged' ] = self.deserialize_purged
 
-    def deserialize_purged( self, trans, item, key, val ):
+    def deserialize_purged( self, item, key, val, **context ):
         """
         If `val` is True, purge `item` and return `item.purged`.
         """

lib/galaxy/managers/hdas.py

@@ -274,9 +274,9 @@ class HDASerializer( # datasets._UnflattenedMetadataDatasetAssociationSerializer
         annotatable.AnnotatableSerializerMixin.add_serializers( self )
 
         self.serializers.update({
-            'model_class'   : lambda *a: 'HistoryDatasetAssociation',
-            'history_content_type': lambda *a: 'dataset',
-            'hda_ldda'      : lambda *a: 'hda',
+            'model_class'   : lambda *a, **c: 'HistoryDatasetAssociation',
+            'history_content_type': lambda *a, **c: 'dataset',
+            'hda_ldda'      : lambda *a, **c: 'hda',
             'type_id'       : self.serialize_type_id,
 
             'history_id'    : self.serialize_id,
@@ -287,7 +287,7 @@ class HDASerializer( # datasets._UnflattenedMetadataDatasetAssociationSerializer
             'file_ext'      : self._remap_from( 'extension' ),
             'file_path'     : self._remap_from( 'file_name' ),
 
-            'resubmitted'   : lambda t, i, k: i._state == t.app.model.Dataset.states.RESUBMITTED,
+            'resubmitted'   : lambda i, k, **c: i._state == model.Dataset.states.RESUBMITTED,
 
             'display_apps'  : self.serialize_display_apps,
             'display_types' : self.serialize_old_display_applications,
@@ -297,24 +297,25 @@ class HDASerializer( # datasets._UnflattenedMetadataDatasetAssociationSerializer
             # TODO: this intermittently causes a routes.GenerationException - temp use the legacy route to prevent this
             #   see also: https://trello.com/c/5d6j4X5y
             #   see also: https://sentry.galaxyproject.org/galaxy/galaxy-main/group/20769/events/9352883/
-            'url'           : lambda t, i, k: self.url_for( 'history_content',
-                history_id=t.security.encode_id( i.history_id ), id=t.security.encode_id( i.id ) ),
+            'url'           : lambda i, k, **c: self.url_for( 'history_content',
+                history_id=self.app.security.encode_id( i.history_id ),
+                id=self.app.security.encode_id( i.id ) ),
             'urls'          : self.serialize_urls,
 
             # TODO: backwards compat: need to go away
-            'download_url'  : lambda t, i, k: self.url_for( 'history_contents_display',
-                history_id=t.security.encode_id( i.history.id ),
-                history_content_id=t.security.encode_id( i.id ) ),
+            'download_url'  : lambda i, k, **c: self.url_for( 'history_contents_display',
+                history_id=self.app.security.encode_id( i.history.id ),
+                history_content_id=self.app.security.encode_id( i.id ) ),
             'parent_id'     : self.serialize_id,
-            'accessible'    : lambda *a: True,
-            'api_type'      : lambda *a: 'file',
-            'type'          : lambda *a: 'file'
+            'accessible'    : lambda *a, **c: True,
+            'api_type'      : lambda *a, **c: 'file',
+            'type'          : lambda *a, **c: 'file'
         })
 
-    def serialize_type_id( self, trans, hda, key ):
-        return 'dataset-' + self.serializers[ 'id' ]( trans, hda, 'id' )
+    def serialize_type_id( self, hda, key, **context ):
+        return 'dataset-' + self.serializers[ 'id' ]( hda, 'id' )
 
-    def serialize_display_apps( self, trans, hda, key ):
+    def serialize_display_apps( self, hda, key, trans=None, **context ):
         """
         Return dictionary containing new-style display app urls.
         """
@@ -333,7 +334,7 @@ class HDASerializer( # datasets._UnflattenedMetadataDatasetAssociationSerializer
 
         return display_apps
 
-    def serialize_old_display_applications( self, trans, hda, key ):
+    def serialize_old_display_applications( self, hda, key, trans=None, **context ):
         """
         Return dictionary containing old-style display app urls.
         """
@@ -360,7 +361,7 @@ class HDASerializer( # datasets._UnflattenedMetadataDatasetAssociationSerializer
 
         return display_apps
 
-    def serialize_visualization_links( self, trans, hda, key ):
+    def serialize_visualization_links( self, hda, key, trans=None, **context ):
         """
         Return a list of dictionaries with links to visualization pages
         for those visualizations that apply to this hda.
@@ -370,7 +371,7 @@ class HDASerializer( # datasets._UnflattenedMetadataDatasetAssociationSerializer
             return hda.get_visualizations()
         return self.app.visualizations_registry.get_visualizations( trans, hda )
 
-    def serialize_urls( self, trans, hda, key ):
+    def serialize_urls( self, hda, key, **context ):
         """
         Return web controller urls useful for this HDA.
         """
@@ -413,8 +414,8 @@ class HDADeserializer( datasets.DatasetAssociationDeserializer,
         self.deserializers.update({
             'visible'       : self.deserialize_bool,
             # remapped
-            'genome_build'  : lambda t, i, k, v: self.deserialize_genome_build( t, i, 'dbkey', v ),
-            'misc_info'     : lambda t, i, k, v: self.deserialize_basestring( t, i, 'info', v ),
+            'genome_build'  : lambda i, k, v, **c: self.deserialize_genome_build( i, 'dbkey', v ),
+            'misc_info'     : lambda i, k, v, **c: self.deserialize_basestring( i, 'info', v ),
         })
         self.deserializable_keyset.update( self.deserializers.keys() )
 

lib/galaxy/managers/histories.py

@@ -129,12 +129,14 @@ class HistoryManager( sharable.SharableModelManager, deletable.PurgableManagerMi
         history_dictionary = {}
         contents_dictionaries = []
         try:
-            history_dictionary = history_serializer.serialize_to_view( trans, history, view='detailed' )
+            history_dictionary = history_serializer.serialize_to_view( history, view='detailed',
+                user=trans.user, trans=trans )
 
             for content in history.contents_iter( types=[ 'dataset', 'dataset_collection' ] ):
                 contents_dict = {}
                 if isinstance( content, model.HistoryDatasetAssociation ):
-                    contents_dict = hda_serializer.serialize_to_view( trans, content, view='detailed' )
+                    contents_dict = hda_serializer.serialize_to_view( content, view='detailed',
+                        user=trans.user, trans=trans )
                 elif isinstance( content, model.HistoryDatasetCollectionAssociation ):
                     try:
                         service = self.app.dataset_collections_service
@@ -212,28 +214,28 @@ class HistorySerializer( sharable.SharableModelSerializer, deletable.PurgableSer
         deletable.PurgableSerializerMixin.add_serializers( self )
 
         self.serializers.update({
-            'model_class'   : lambda *a: 'History',
+            'model_class'   : lambda *a, **c: 'History',
             'id'            : self.serialize_id,
             'create_time'   : self.serialize_date,
             'update_time'   : self.serialize_date,
-            'size'          : lambda t, i, k: int( i.get_disk_size() ),
-            'nice_size'     : lambda t, i, k: i.get_disk_size( nice_size=True ),
+            'size'          : lambda i, k, **c: int( i.get_disk_size() ),
+            'nice_size'     : lambda i, k, **c: i.get_disk_size( nice_size=True ),
             'state'         : self.serialize_history_state,
 
-            'url'           : lambda t, i, k: self.url_for( 'history', id=t.security.encode_id( i.id ) ),
-            'contents_url'  : lambda t, i, k: self.url_for( 'history_contents',
-                history_id=t.security.encode_id( i.id ) ),
+            'url'           : lambda i, k, **c: self.url_for( 'history', id=self.app.security.encode_id( i.id ) ),
+            'contents_url'  : lambda i, k, **c: self.url_for( 'history_contents',
+                history_id=self.app.security.encode_id( i.id ) ),
 
-            'empty'         : lambda t, i, k: ( len( i.datasets ) + len( i.dataset_collections ) ) <= 0,
-            'count'         : lambda trans, item, key: len( item.datasets ),
-            'hdas'          : lambda t, i, k: [ t.security.encode_id( hda.id ) for hda in i.datasets ],
+            'empty'         : lambda i, k, **c: ( len( i.datasets ) + len( i.dataset_collections ) ) <= 0,
+            'count'         : lambda i, k, **c: len( i.datasets ),
+            'hdas'          : lambda i, k, **c: [ self.app.security.encode_id( hda.id ) for hda in i.datasets ],
             'state_details' : self.serialize_state_counts,
             'state_ids'     : self.serialize_state_ids,
             'contents'      : self.serialize_contents
         })
 
     # remove this
-    def serialize_state_ids( self, trans, history, key ):
+    def serialize_state_ids( self, history, key, **context ):
         """
         Return a dictionary keyed to possible dataset states and valued with lists
         containing the ids of each HDA in that state.
@@ -250,7 +252,7 @@ class HistorySerializer( sharable.SharableModelSerializer, deletable.PurgableSer
         return state_ids
 
     # remove this
-    def serialize_state_counts( self, trans, history, key, exclude_deleted=True, exclude_hidden=False ):
+    def serialize_state_counts( self, history, key, exclude_deleted=True, exclude_hidden=False, **context ):
         """
         Return a dictionary keyed to possible dataset states and valued with the number
         of datasets in this history that have those states.
@@ -270,7 +272,7 @@ class HistorySerializer( sharable.SharableModelSerializer, deletable.PurgableSer
         return state_counts
 
     # TODO: remove this (is state used/useful?)
-    def serialize_history_state( self, trans, history, key ):
+    def serialize_history_state( self, history, key, **context ):
         """
         Returns the history state based on the states of the HDAs it contains.
         """
@@ -279,7 +281,7 @@ class HistorySerializer( sharable.SharableModelSerializer, deletable.PurgableSer
         state = states.ERROR
         # TODO: history_state and state_counts are classically calc'd at the same time
         #   so this is rel. ineff. - if we keep this...
-        hda_state_counts = self.serialize_state_counts( trans, history, 'counts', exclude_deleted=False )
+        hda_state_counts = self.serialize_state_counts( history, 'counts', exclude_deleted=False, **context )
         num_hdas = sum( hda_state_counts.values() )
         if num_hdas == 0:
             state = states.NEW
@@ -300,17 +302,18 @@ class HistorySerializer( sharable.SharableModelSerializer, deletable.PurgableSer
 
         return state
 
-    def serialize_contents( self, trans, history, *args ):
+    def serialize_contents( self, history, *args, **context ):
         contents_dictionaries = []
         for content in history.contents_iter( types=[ 'dataset', 'dataset_collection' ] ):
             contents_dict = {}
             if isinstance( content, model.HistoryDatasetAssociation ):
-                contents_dict = self.hda_serializer.serialize_to_view( trans, content, view='detailed' )
-            elif isinstance( content, model.HistoryDatasetCollectionAssociation ):
-                contents_dict = self._serialize_collection( trans, content )
+                contents_dict = self.hda_serializer.serialize_to_view( content, view='detailed', **context )
+            # elif isinstance( content, model.HistoryDatasetCollectionAssociation ):
+            #     contents_dict = self._serialize_collection( trans, content )
             contents_dictionaries.append( contents_dict )
         return contents_dictionaries
 
+    # TODO: remove trans
     def _serialize_collection( self, trans, collection ):
         service = self.app.dataset_collections_service
         dataset_collection_instance = service.get_dataset_collection_instance(

lib/galaxy/managers/ratable.py

@@ -26,12 +26,12 @@ class RatableSerializerMixin( object ):
         self.serializers[ 'user_rating' ] = self.serialize_user_rating
         self.serializers[ 'community_rating' ] = self.serialize_community_rating
 
-    def serialize_user_rating( self, trans, item, key ):
+    def serialize_user_rating( self, item, key, user=None, **context ):
         """
         """
         pass
 
-    def serialize_community_rating( self, trans, item, key ):
+    def serialize_community_rating( self, item, key, **context ):
         """
         """
         pass

lib/galaxy/managers/sharable.py

@@ -321,13 +321,13 @@ class SharableModelSerializer( base.ModelSerializer,
             'importable', 'published', 'slug'
         ])
 
-    def serialize_username_and_slug( self, trans, item, key ):
+    def serialize_username_and_slug( self, item, key, **context ):
         if not ( item.user and item.slug and self.SINGLE_CHAR_ABBR ):
             return None
 #TODO: self.url_for
         return ( '/' ).join(( 'u', item.user.username, self.SINGLE_CHAR_ABBR, item.slug ) )
 
-    #def published_url( self, trans, item, key ):
+    #def published_url( self, item, key, **context ):
     #    """
     #    """
     #    url = url_for(controller='history', action="display_by_username_and_slug",
@@ -354,7 +354,7 @@ class SharableModelDeserializer( base.ModelDeserializer,
             'importable'    : self.deserialize_importable,
         })
 
-    def deserialize_published( self, trans, item, key, val ):
+    def deserialize_published( self, item, key, val, **context ):
         """
         """
         val = self.validate.bool( key, val )
@@ -367,7 +367,7 @@ class SharableModelDeserializer( base.ModelDeserializer,
             self.manager.unpublish( item, flush=False )
         return item.published
 
-    def deserialize_importable( self, trans, item, key, val ):
+    def deserialize_importable( self, item, key, val, **context ):
         """
         """
         val = self.validate.bool( key, val )
@@ -380,7 +380,7 @@ class SharableModelDeserializer( base.ModelDeserializer,
             self.manager.make_non_importable( item, flush=False )
         return item.published
 
-    #def deserialize_slug( self, trans, item, val ):
+    #def deserialize_slug( self, item, val, **context ):
     #    """
     #    """
     #    #TODO: call manager.set_slug

lib/galaxy/managers/taggable.py

@@ -15,7 +15,7 @@ class TaggableManagerMixin( object ):
 
     #TODO: most of this can be done by delegating to the TagManager?
 
-    #def by_user( self, trans, user, **kwargs ):
+    #def by_user( self, user, **kwargs ):
     #    pass
 
 
@@ -24,7 +24,7 @@ class TaggableSerializerMixin( object ):
     def add_serializers( self ):
         self.serializers[ 'tags' ] = self.serialize_tags
 
-    def serialize_tags( self, trans, item, key ):
+    def serialize_tags( self, item, key, **context ):
         """
         Return tags as a list of strings.
         """
@@ -45,7 +45,7 @@ class TaggableDeserializerMixin( object ):
     def add_deserializers( self ):
         self.deserializers[ 'tags' ] = self.deserialize_tags
 
-    def deserialize_tags( self, trans, item, key, val ):
+    def deserialize_tags( self, item, key, val, user=None, **context ):
         """
         Make sure `val` is a valid list of tag strings and assign them.
 
@@ -53,8 +53,6 @@ class TaggableDeserializerMixin( object ):
         """
         new_tags_list = self.validate.basestring_list( key, val )
         #TODO: have to assume trans.user here...
-        #TODO: trans
-        user = trans.user
         #TODO: duped from tags manager - de-dupe when moved to taggable mixin
         tag_handler = self.app.tag_handler
         tag_handler.delete_item_tags( user, item )

lib/galaxy/managers/users.py

@@ -281,36 +281,38 @@ class UserSerializer( base.ModelSerializer, deletable.PurgableSerializerMixin ):
             'id'            : self.serialize_id,
             'create_time'   : self.serialize_date,
             'update_time'   : self.serialize_date,
-            'is_admin'      : lambda t, i, k: self.user_manager.is_admin( i ),
+            'is_admin'      : lambda i, k, **c: self.user_manager.is_admin( i ),
 
-            'total_disk_usage' : lambda t, i, k: float( i.total_disk_usage ),
-            'quota_percent' : lambda t, i, k: self.user_manager.quota( i ),
+            'total_disk_usage' : lambda i, k, **c: float( i.total_disk_usage ),
+            'quota_percent' : lambda i, k, **c: self.user_manager.quota( i ),
 
-            'tags_used'     : lambda t, i, k: self.user_manager.tags_used( i ),
+            'tags_used'     : lambda i, k, **c: self.user_manager.tags_used( i ),
             #TODO: 'has_requests' is more apt
-            'requests'      : lambda t, i, k: self.user_manager.has_requests( i, t )
+            'requests'      : lambda i, k, trans=None, **c: self.user_manager.has_requests( i, trans )
         })
 
 
 class CurrentUserSerializer( UserSerializer ):
 
-    def serialize( self, trans, user, keys ):
+    def serialize( self, user, keys, **kwargs ):
         """
         Override to return at least some usage info if user is anonymous.
         """
+# hmmm.
+        kwargs[ 'current_user' ] = user
         if self.user_manager.is_anonymous( user ):
-            return self.serialize_current_anonymous_user( trans, user, keys )
-        return super( UserSerializer, self ).serialize( trans, user, keys )
+            return self.serialize_current_anonymous_user( user, keys, **kwargs )
+        return super( UserSerializer, self ).serialize( user, keys, **kwargs )
 
-    def serialize_current_anonymous_user( self, trans, user, keys ):
+    def serialize_current_anonymous_user( self, user, keys, trans=None, **kwargs ):
         # use the current history if any to get usage stats for trans' anonymous user
         #TODO: might be better as sep. Serializer class
         history = trans.history
         if not history:
             raise exceptions.AuthenticationRequired( 'No history for anonymous user usage stats' );
 
-        usage = trans.app.quota_agent.get_usage( trans, history=trans.history )
-        percent = trans.app.quota_agent.get_percent( trans=trans, usage=usage )
+        usage = self.app.quota_agent.get_usage( trans, history=trans.history )
+        percent = self.app.quota_agent.get_percent( trans=trans, usage=usage )
 
         # a very small subset of keys available
         values = {

lib/galaxy/webapps/galaxy/api/configuration.py

@@ -9,6 +9,7 @@ from galaxy.web import require_admin
 from galaxy.web.base.controller import BaseAPIController
 
 from galaxy.managers import base
+from galaxy.managers import configuration
 
 import logging
 log = logging.getLogger( __name__ )
@@ -18,8 +19,8 @@ class ConfigurationController( BaseAPIController ):
 
     def __init__( self, app ):
         super( ConfigurationController, self ).__init__( app )
-        self.config_serializer = ConfigSerializer( app )
-        self.admin_config_serializer = AdminConfigSerializer( app )
+        self.config_serializer = configuration.ConfigSerializer( app )
+        self.admin_config_serializer = configuration.AdminConfigSerializer( app )
 
     @expose_api_anonymous_and_sessionless
     def index( self, trans, **kwd ):
@@ -57,8 +58,7 @@ class ConfigurationController( BaseAPIController ):
             #TODO: this should probably just be under a different route: 'admin/configuration'
             serializer = self.admin_config_serializer
 
-        serialized = serializer.serialize_to_view( trans, self.app.config,
-                                                   view=view, keys=keys, default_view=default_view )
+        serialized = serializer.serialize_to_view( self.app.config, view=view, keys=keys, default_view=default_view )
         return serialized
 
     @expose_api
@@ -85,77 +85,6 @@ class ConfigurationController( BaseAPIController ):
         return rval
 
 
-#TODO: for lack of a manager file for the config. May well be better in config.py? Circ imports?
-class ConfigSerializer( base.ModelSerializer ):
-
-    def __init__( self, app ):
-        super( ConfigSerializer, self ).__init__( app )
-
-        self.default_view = 'all'
-        self.add_view( 'all', self.serializers.keys() )
-
-    def default_serializer( self, trans, config, key ):
-        return getattr( config, key, None )
-
-    def add_serializers( self ):
-        def _defaults_to( default ):
-            return lambda t, i, k: getattr( i, k, default )
-
-        self.serializers = {
-            #TODO: this is available from user data, remove
-            'is_admin_user'             : lambda *a: False,
-
-            'brand'                     : _defaults_to( '' ),
-            #TODO: this doesn't seem right
-            'logo_url'                  : lambda t, i, k: self.url_for( i.get( k, '/' ) ),
-            'terms_url'                 : _defaults_to( '' ),
-
-            #TODO: don't hardcode here - hardcode defaults once in config.py
-            'wiki_url'                  : _defaults_to( "http://galaxyproject.org/" ),
-            'search_url'                : _defaults_to( "http://galaxyproject.org/search/usegalaxy/" ),
-            'mailing_lists'             : _defaults_to( "http://wiki.galaxyproject.org/MailingLists" ),
-            'screencasts_url'           : _defaults_to( "http://vimeo.com/galaxyproject" ),
-            'citation_url'              : _defaults_to( "http://wiki.galaxyproject.org/CitingGalaxy" ),
-            'support_url'               : _defaults_to( "http://wiki.galaxyproject.org/Support" ),
-            'lims_doc_url'              : _defaults_to( "http://main.g2.bx.psu.edu/u/rkchak/p/sts" ),
-            'biostar_url'               : _defaults_to( '' ),
-            'biostar_url_redirect'      : lambda *a: self.url_for( controller='biostar', action='biostar_redirect',
-                                                                   qualified=True ),
-
-            'use_remote_user'           : _defaults_to( None ),
-            'remote_user_logout_href'   : _defaults_to( '' ),
-            'enable_cloud_launch'       : _defaults_to( False ),
-            'datatypes_disable_auto'    : _defaults_to( False ),
-            'allow_user_dataset_purge'  : _defaults_to( False ),
-            'enable_unique_workflow_defaults' : _defaults_to( False ),
-
-            'nginx_upload_path'         : _defaults_to( self.url_for( controller='api', action='tools' ) ),
-            'ftp_upload_dir'            : _defaults_to( None ),
-            'ftp_upload_site'           : _defaults_to( None ),
-            'version_major'             : _defaults_to( None ),
-        }
-
-
-class AdminConfigSerializer( ConfigSerializer ):
-    # config attributes viewable by admin users
-
-    def add_serializers( self ):
-        super( AdminConfigSerializer, self ).add_serializers()
-        def _defaults_to( default ):
-            return lambda t, i, k: getattr( i, k, default )
-
-        self.serializers.update({
-            #TODO: this is available from user data, remove
-            'is_admin_user'             : lambda *a: True,
-
-            'library_import_dir'        : _defaults_to( None ),
-            'user_library_import_dir'   : _defaults_to( None ),
-            'allow_library_path_paste'  : _defaults_to( False ),
-            'allow_user_creation'       : _defaults_to( False ),
-            'allow_user_deletion'       : _defaults_to( False ),
-        })
-
-
 def _tool_conf_to_dict(conf):
     return dict(
         config_filename=conf['config_filename'],

lib/galaxy/webapps/galaxy/api/datasets.py

@@ -66,7 +66,8 @@ class DatasetsController( BaseAPIController, UsesVisualizationMixin ):
             else:
                 # Default: return dataset as dict.
                 if hda_ldda == 'hda':
-                    return self.hda_serializer.serialize_to_view( trans, dataset, view=kwd.get( 'view', 'detailed' ) )
+                    return self.hda_serializer.serialize_to_view( dataset,
+                        view=kwd.get( 'view', 'detailed' ), user=trans.user, trans=trans )
                 else:
                     rval = dataset.to_dict()
 

lib/galaxy/webapps/galaxy/api/histories.py

@@ -103,8 +103,11 @@ class HistoriesController( BaseAPIController, ExportsHistoryMixin, ImportsHistor
         current_user = self.user_manager.current_user( trans )
         if self.user_manager.is_anonymous( current_user ):
             current_history = self.history_manager.get_current( trans )
+            if not current_history:
+                return []
             #note: ignores filters, limit, offset
-            return [ self.history_serializer.serialize_to_view( trans, current_history, **serialization_params ) ]
+            return [ self.history_serializer.serialize_to_view( current_history,
+                     user=current_user, trans=trans, **serialization_params ) ]
 
         filters = []
         # support the old default of not-returning/filtering-out deleted histories
@@ -120,7 +123,8 @@ class HistoriesController( BaseAPIController, ExportsHistoryMixin, ImportsHistor
 
         rval = []
         for history in histories:
-            history_dict = self.history_serializer.serialize_to_view( trans, history, **serialization_params )
+            history_dict = self.history_serializer.serialize_to_view( history,
+                user=trans.user, trans=trans, **serialization_params )
             rval.append( history_dict )
         return rval
 
@@ -179,8 +183,8 @@ class HistoriesController( BaseAPIController, ExportsHistoryMixin, ImportsHistor
         else:
             history = self.history_manager.get_accessible( self.decode_id( history_id ), trans.user, current_history=trans.history )
 
-        return self.history_serializer.serialize_to_view( trans, history,
-            **self._parse_serialization_params( kwd, 'detailed' ) )
+        return self.history_serializer.serialize_to_view( history,
+            user=trans.user, trans=trans, **self._parse_serialization_params( kwd, 'detailed' ) )
 
     @expose_api_anonymous
     def citations( self, trans, history_id, **kwd ):
@@ -245,8 +249,8 @@ class HistoriesController( BaseAPIController, ExportsHistoryMixin, ImportsHistor
         trans.sa_session.add( new_history )
         trans.sa_session.flush()
 
-        return self.history_serializer.serialize_to_view( trans, new_history,
-            **self._parse_serialization_params( kwd, 'detailed' ) )
+        return self.history_serializer.serialize_to_view( new_history,
+            user=trans.user, trans=trans, **self._parse_serialization_params( kwd, 'detailed' ) )
 
     @expose_api
     def delete( self, trans, id, **kwd ):
@@ -284,8 +288,8 @@ class HistoriesController( BaseAPIController, ExportsHistoryMixin, ImportsHistor
         if purge:
             self.history_manager.purge( history )
 
-        return self.history_serializer.serialize_to_view( trans, history,
-            **self._parse_serialization_params( kwd, 'detailed' ) )
+        return self.history_serializer.serialize_to_view( history,
+            user=trans.user, trans=trans, **self._parse_serialization_params( kwd, 'detailed' ) )
 
     @expose_api
     def undelete( self, trans, id, **kwd ):
@@ -307,8 +311,8 @@ class HistoriesController( BaseAPIController, ExportsHistoryMixin, ImportsHistor
         history = self.history_manager.get_owned( self.decode_id( history_id ), trans.user, current_history=trans.history )
         self.history_manager.undelete( history )
 
-        return self.history_serializer.serialize_to_view( trans, history,
-            **self._parse_serialization_params( kwd, 'detailed' ) )
+        return self.history_serializer.serialize_to_view( history,
+            user=trans.user, trans=trans, **self._parse_serialization_params( kwd, 'detailed' ) )
 
     @expose_api
     def update( self, trans, id, payload, **kwd ):
@@ -335,9 +339,9 @@ class HistoriesController( BaseAPIController, ExportsHistoryMixin, ImportsHistor
         #TODO: PUT /api/histories/{encoded_history_id} payload = { rating: rating } (w/ no security checks)
         history = self.history_manager.get_owned( self.decode_id( id ), trans.user, current_history=trans.history )
 
-        self.history_deserializer.deserialize( trans, history, payload )
-        return self.history_serializer.serialize_to_view( trans, history,
-            **self._parse_serialization_params( kwd, 'detailed' ) )
+        self.history_deserializer.deserialize( history, payload, user=trans.user, trans=trans )
+        return self.history_serializer.serialize_to_view( history,
+            user=trans.user, trans=trans, **self._parse_serialization_params( kwd, 'detailed' ) )
 
     @expose_api
     def archive_export( self, trans, id, **kwds ):

lib/galaxy/webapps/galaxy/api/history_contents.py

@@ -102,7 +102,7 @@ class HistoryContentsController( BaseAPIController, UsesLibraryMixin, UsesLibrar
 
             if isinstance( content, trans.app.model.HistoryDatasetAssociation ):
                 view = 'detailed' if detailed else 'summary'
-                hda_dict = self.hda_serializer.serialize_to_view( trans, content, view=view )
+                hda_dict = self.hda_serializer.serialize_to_view( content, view=view, user=trans.user, trans=trans )
                 rval.append( hda_dict )
 
             elif isinstance( content, trans.app.model.HistoryDatasetCollectionAssociation ):
@@ -144,8 +144,8 @@ class HistoryContentsController( BaseAPIController, UsesLibraryMixin, UsesLibrar
 
     def __show_dataset( self, trans, id, **kwd ):
         hda = self.hda_manager.get_accessible( self.decode_id( id ), trans.user )
-        return self.hda_serializer.serialize_to_view( trans, hda,
-            **self._parse_serialization_params( kwd, 'detailed' ) )
+        return self.hda_serializer.serialize_to_view( hda,
+            user=trans.user, trans=trans, **self._parse_serialization_params( kwd, 'detailed' ) )
 
     def __show_dataset_collection( self, trans, id, history_id, **kwd ):
         try:
@@ -257,8 +257,8 @@ class HistoryContentsController( BaseAPIController, UsesLibraryMixin, UsesLibrar
         trans.sa_session.flush()
         if not hda:
             return None
-        return self.hda_serializer.serialize_to_view( trans, hda,
-            **self._parse_serialization_params( kwd, 'detailed' ) )
+        return self.hda_serializer.serialize_to_view( hda,
+            user=trans.user, trans=trans, **self._parse_serialization_params( kwd, 'detailed' ) )
 
     def __create_dataset_collection( self, trans, history, payload, **kwd ):
         source = kwd.get("source", "new_collection")
@@ -344,12 +344,12 @@ class HistoryContentsController( BaseAPIController, UsesLibraryMixin, UsesLibrar
         # make the actual changes
         #TODO: is this if still needed?
         if hda and isinstance( hda, trans.model.HistoryDatasetAssociation ):
-            self.hda_deserializer.deserialize( trans, hda, payload )
+            self.hda_deserializer.deserialize( hda, payload, user=trans.user, trans=trans )
             #TODO: this should be an effect of deleting the hda
             if payload.get( 'deleted', False ):
                 self.hda_manager.stop_creating_job( hda )
-            return self.hda_serializer.serialize_to_view( trans, hda,
-                **self._parse_serialization_params( kwd, 'detailed' ) )
+            return self.hda_serializer.serialize_to_view( hda,
+                user=trans.user, trans=trans, **self._parse_serialization_params( kwd, 'detailed' ) )
 
         return {}
 
@@ -407,8 +407,8 @@ class HistoryContentsController( BaseAPIController, UsesLibraryMixin, UsesLibrar
             self.hda_manager.purge( hda )
         else:
             self.hda_manager.delete( hda )
-        return self.hda_serializer.serialize_to_view( trans, hda,
-            **self._parse_serialization_params( kwd, 'detailed' ) )
+        return self.hda_serializer.serialize_to_view( hda,
+            user=trans.user, trans=trans, **self._parse_serialization_params( kwd, 'detailed' ) )
 
     def __handle_unknown_contents_type( self, trans, contents_type ):
         raise exceptions.UnknownContentsType('Unknown contents type: %s' % type)

lib/galaxy/webapps/galaxy/controllers/history.py

@@ -642,7 +642,8 @@ class HistoryController( BaseUIController, SharableMixin, UsesAnnotations, UsesI
 
         history_dictionaries = []
         for history in self.history_manager.by_user( trans.user, filters=deleted_filter ):
-            history_dictionary = self.history_serializer.serialize_to_view( trans, history, view='detailed' )
+            history_dictionary = self.history_serializer.serialize_to_view( history,
+                view='detailed', user=trans.user, trans=trans )
             history_dictionaries.append( history_dictionary )
 
         return trans.fill_template_mako( "history/view_multiple.mako",
@@ -1501,7 +1502,7 @@ class HistoryController( BaseUIController, SharableMixin, UsesAnnotations, UsesI
     def history_data( self, trans, history ):
         """
         """
-        return self.history_serializer.serialize_to_view( trans, history, view='detailed' )
+        return self.history_serializer.serialize_to_view( history, view='detailed', user=trans.user, trans=trans )
 
     #TODO: combine these next two - poss. with a redirect flag
     #@web.require_login( "switch to a history" )
@@ -1512,7 +1513,7 @@ class HistoryController( BaseUIController, SharableMixin, UsesAnnotations, UsesI
         try:
             history = self.history_manager.get_owned( self.decode_id( id ), trans.user, current_history=trans.history )
             trans.set_history( history )
-            return self.history_serializer.serialize_to_view( trans, history, view='detailed' )
+            return self.history_serializer.serialize_to_view( history, view='detailed', user=trans.user, trans=trans )
         except exceptions.MessageException, msg_exc:
             trans.response.status = msg_exc.err_code.code
             return { 'err_msg': msg_exc.err_msg, 'err_code': msg_exc.err_code.code }
@@ -1522,13 +1523,13 @@ class HistoryController( BaseUIController, SharableMixin, UsesAnnotations, UsesI
         """
         """
         history = trans.get_history( create=True )
-        return self.history_serializer.serialize_to_view( trans, history, view='detailed' )
+        return self.history_serializer.serialize_to_view( history, view='detailed', user=trans.user, trans=trans )
 
     @web.json
     def create_new_current( self, trans, name=None ):
         """
         """
         new_history = trans.new_history( name )
-        return self.history_serializer.serialize_to_view( trans, new_history, view='detailed' )
+        return self.history_serializer.serialize_to_view( new_history, view='detailed', user=trans.user, trans=trans )
 
     #TODO: /history/current to do all of the above: if ajax, return json; if post, read id and set to current

test/unit/managers/test_DatasetManager.py

@@ -197,11 +197,11 @@ class DatasetSerializerTestCase( BaseTestCase ):
         dataset = self.dataset_manager.create()
 
         self.log( 'should have a summary view' )
-        summary_view = self.dataset_serializer.serialize_to_view( self.trans, dataset, view='summary' )
+        summary_view = self.dataset_serializer.serialize_to_view( dataset, view='summary' )
         self.assertKeys( summary_view, self.dataset_serializer.views[ 'summary' ] )
 
         self.log( 'should have the summary view as default view' )
-        default_view = self.dataset_serializer.serialize_to_view( self.trans, dataset, default_view='summary' )
+        default_view = self.dataset_serializer.serialize_to_view( dataset, default_view='summary' )
         self.assertKeys( summary_view, self.dataset_serializer.views[ 'summary' ] )
 
         self.log( 'should have a serializer for all serializable keys' )
@@ -217,13 +217,13 @@ class DatasetSerializerTestCase( BaseTestCase ):
         dataset = self.dataset_manager.create()
 
         self.log( 'should be able to use keys with views' )
-        serialized = self.dataset_serializer.serialize_to_view( self.trans, dataset,
+        serialized = self.dataset_serializer.serialize_to_view( dataset,
             view='summary', keys=[ 'permissions' ] )
         self.assertKeys( serialized,
             self.dataset_serializer.views[ 'summary' ] + [ 'permissions' ] )
 
         self.log( 'should be able to use keys on their own' )
-        serialized = self.dataset_serializer.serialize_to_view( self.trans, dataset,
+        serialized = self.dataset_serializer.serialize_to_view( dataset,
             keys=[ 'purgable', 'file_size' ] )
         self.assertKeys( serialized, [ 'purgable', 'file_size' ] )
 
@@ -235,7 +235,7 @@ class DatasetSerializerTestCase( BaseTestCase ):
         user2 = self.user_manager.create( **user2_data )
         dataset = self.dataset_manager.create()
         all_keys = list( self.dataset_serializer.serializable_keyset )
-        serialized = self.dataset_serializer.serialize( self.trans, dataset, all_keys )
+        serialized = self.dataset_serializer.serialize( dataset, all_keys )
 
         self.log( 'everything serialized should be of the proper type' )
         self.assertEncodedId( serialized[ 'id' ] )
@@ -270,13 +270,13 @@ class DatasetDeserializerTestCase( BaseTestCase ):
         self.log( 'should raise when deserializing deleted from non-bool' )
         self.assertFalse( dataset.deleted )
         self.assertRaises( exceptions.RequestParameterInvalidException,
-            self.dataset_deserializer.deserialize, self.trans, dataset, data={ 'deleted': None } )
+            self.dataset_deserializer.deserialize, dataset, data={ 'deleted': None } )
         self.assertFalse( dataset.deleted )
         self.log( 'should be able to deserialize deleted from True' )
-        self.dataset_deserializer.deserialize( self.trans, dataset, data={ 'deleted': True } )
+        self.dataset_deserializer.deserialize( dataset, data={ 'deleted': True } )
         self.assertTrue( dataset.deleted )
         self.log( 'should be able to reverse by deserializing deleted from False' )
-        self.dataset_deserializer.deserialize( self.trans, dataset, data={ 'deleted': False } )
+        self.dataset_deserializer.deserialize( dataset, data={ 'deleted': False } )
         self.assertFalse( dataset.deleted )
 
     def test_deserialize_purge( self ):
@@ -284,14 +284,14 @@ class DatasetDeserializerTestCase( BaseTestCase ):
 
         self.log( 'should raise when deserializing purged from non-bool' )
         self.assertRaises( exceptions.RequestParameterInvalidException,
-            self.dataset_deserializer.deserialize, self.trans, dataset, data={ 'purged': None } )
+            self.dataset_deserializer.deserialize, dataset, data={ 'purged': None } )
         self.assertFalse( dataset.purged )
         self.log( 'should be able to deserialize purged from True' )
-        self.dataset_deserializer.deserialize( self.trans, dataset, data={ 'purged': True } )
+        self.dataset_deserializer.deserialize( dataset, data={ 'purged': True } )
         self.assertTrue( dataset.purged )
         # TODO: should this raise an error?
         self.log( 'should NOT be able to deserialize purged from False (will remain True)' )
-        self.dataset_deserializer.deserialize( self.trans, dataset, data={ 'purged': False } )
+        self.dataset_deserializer.deserialize( dataset, data={ 'purged': False } )
         self.assertTrue( dataset.purged )
 
     # def test_deserialize_permissions( self ):

test/unit/managers/test_HDAManager.py

@@ -324,23 +324,23 @@ class HDASerializerTestCase( HDATestCase ):
         hda = self._create_vanilla_hda()
 
         self.log( 'should have a summary view' )
-        summary_view = self.hda_serializer.serialize_to_view( self.trans, hda, view='summary' )
+        summary_view = self.hda_serializer.serialize_to_view( hda, view='summary' )
         self.assertKeys( summary_view, self.hda_serializer.views[ 'summary' ] )
 
         self.log( 'should have the summary view as default view' )
-        default_view = self.hda_serializer.serialize_to_view( self.trans, hda, default_view='summary' )
+        default_view = self.hda_serializer.serialize_to_view( hda, default_view='summary' )
         self.assertKeys( summary_view, self.hda_serializer.views[ 'summary' ] )
 
         # self.log( 'should have a detailed view' )
-        # detailed_view = self.hda_serializer.serialize_to_view( self.trans, hda, view='detailed' )
+        # detailed_view = self.hda_serializer.serialize_to_view( hda, view='detailed' )
         # self.assertKeys( detailed_view, self.hda_serializer.views[ 'detailed' ] )
 
         # self.log( 'should have a extended view' )
-        # extended_view = self.hda_serializer.serialize_to_view( self.trans, hda, view='extended' )
+        # extended_view = self.hda_serializer.serialize_to_view( hda, view='extended' )
         # self.assertKeys( extended_view, self.hda_serializer.views[ 'extended' ] )
 
         self.log( 'should have a inaccessible view' )
-        inaccessible_view = self.hda_serializer.serialize_to_view( self.trans, hda, view='inaccessible' )
+        inaccessible_view = self.hda_serializer.serialize_to_view( hda, view='inaccessible' )
         self.assertKeys( inaccessible_view, self.hda_serializer.views[ 'inaccessible' ] )
 
         # skip metadata for this test
@@ -362,20 +362,20 @@ class HDASerializerTestCase( HDATestCase ):
         hda = self._create_vanilla_hda()
 
         self.log( 'should be able to use keys with views' )
-        serialized = self.hda_serializer.serialize_to_view( self.trans, hda,
+        serialized = self.hda_serializer.serialize_to_view( hda,
             view='summary', keys=[ 'uuid' ] )
         self.assertKeys( serialized,
             self.hda_serializer.views[ 'summary' ] + [ 'uuid' ] )
 
         self.log( 'should be able to use keys on their own' )
-        serialized = self.hda_serializer.serialize_to_view( self.trans, hda,
+        serialized = self.hda_serializer.serialize_to_view( hda,
             keys=[ 'file_path', 'visualizations' ] )
         self.assertKeys( serialized, [ 'file_path', 'visualizations' ] )
 
     def test_serializers( self ):
         hda = self._create_vanilla_hda()
         all_keys = list( self.hda_serializer.serializable_keyset )
-        serialized = self.hda_serializer.serialize( self.trans, hda, all_keys )
+        serialized = self.hda_serializer.serialize( hda, all_keys )
 
         self.log( 'everything serialized should be of the proper type' )
         # base
@@ -449,13 +449,13 @@ class HDADeserializerTestCase( HDATestCase ):
         self.log( 'should raise when deserializing deleted from non-bool' )
         self.assertFalse( hda.deleted )
         self.assertRaises( exceptions.RequestParameterInvalidException,
-            self.hda_deserializer.deserialize, self.trans, hda, data={ 'deleted': None } )
+            self.hda_deserializer.deserialize, hda, { 'deleted': None } )
         self.assertFalse( hda.deleted )
         self.log( 'should be able to deserialize deleted from True' )
-        self.hda_deserializer.deserialize( self.trans, hda, data={ 'deleted': True } )
+        self.hda_deserializer.deserialize( hda, { 'deleted': True } )
         self.assertTrue( hda.deleted )
         self.log( 'should be able to reverse by deserializing deleted from False' )
-        self.hda_deserializer.deserialize( self.trans, hda, data={ 'deleted': False } )
+        self.hda_deserializer.deserialize( hda, { 'deleted': False } )
         self.assertFalse( hda.deleted )
 
     def test_deserialize_purge( self ):
@@ -463,14 +463,14 @@ class HDADeserializerTestCase( HDATestCase ):
 
         self.log( 'should raise when deserializing purged from non-bool' )
         self.assertRaises( exceptions.RequestParameterInvalidException,
-            self.hda_deserializer.deserialize, self.trans, hda, data={ 'purged': None } )
+            self.hda_deserializer.deserialize, hda, { 'purged': None } )
         self.assertFalse( hda.purged )
         self.log( 'should be able to deserialize purged from True' )
-        self.hda_deserializer.deserialize( self.trans, hda, data={ 'purged': True } )
+        self.hda_deserializer.deserialize( hda, { 'purged': True } )
         self.assertTrue( hda.purged )
         # TODO: should this raise an error?
         self.log( 'should NOT be able to deserialize purged from False (will remain True)' )
-        self.hda_deserializer.deserialize( self.trans, hda, data={ 'purged': False } )
+        self.hda_deserializer.deserialize( hda, { 'purged': False } )
         self.assertTrue( hda.purged )
 
     def test_deserialize_visible( self ):
@@ -479,13 +479,13 @@ class HDADeserializerTestCase( HDATestCase ):
         self.log( 'should raise when deserializing from non-bool' )
         self.assertTrue( hda.visible )
         self.assertRaises( exceptions.RequestParameterInvalidException,
-            self.hda_deserializer.deserialize, self.trans, hda, data={ 'visible': 'None' } )
+            self.hda_deserializer.deserialize, hda, { 'visible': 'None' } )
         self.assertTrue( hda.visible )
         self.log( 'should be able to deserialize from False' )
-        self.hda_deserializer.deserialize( self.trans, hda, data={ 'visible': False } )
+        self.hda_deserializer.deserialize( hda, { 'visible': False } )
         self.assertFalse( hda.visible )
         self.log( 'should be able to reverse by deserializing from True' )
-        self.hda_deserializer.deserialize( self.trans, hda, data={ 'visible': True } )
+        self.hda_deserializer.deserialize( hda, { 'visible': True } )
         self.assertTrue( hda.visible )
 
     def test_deserialize_genome_build( self ):
@@ -493,17 +493,17 @@ class HDADeserializerTestCase( HDATestCase ):
 
         self.assertIsInstance( hda.dbkey, basestring )
         self.log( 'should deserialize to "?" from None' )
-        self.hda_deserializer.deserialize( self.trans, hda, data={ 'genome_build': None } )
+        self.hda_deserializer.deserialize( hda, { 'genome_build': None } )
         self.assertEqual( hda.dbkey, '?' )
         self.log( 'should raise when deserializing from non-string' )
         self.assertRaises( exceptions.RequestParameterInvalidException,
-            self.hda_deserializer.deserialize, self.trans, hda, data={ 'genome_build': 12 } )
+            self.hda_deserializer.deserialize, hda, { 'genome_build': 12 } )
         self.log( 'should be able to deserialize from unicode' )
         date_palm = u'نخيل التمر'
-        self.hda_deserializer.deserialize( self.trans, hda, data={ 'genome_build': date_palm } )
+        self.hda_deserializer.deserialize( hda, { 'genome_build': date_palm } )
         self.assertEqual( hda.dbkey, date_palm )
         self.log( 'should be deserializable from empty string' )
-        self.hda_deserializer.deserialize( self.trans, hda, data={ 'genome_build': '' } )
+        self.hda_deserializer.deserialize( hda, { 'genome_build': '' } )
         self.assertEqual( hda.dbkey, '' )
 
     def test_deserialize_name( self ):
@@ -511,19 +511,19 @@ class HDADeserializerTestCase( HDATestCase ):
 
         self.log( 'should raise when deserializing from non-string' )
         self.assertRaises( exceptions.RequestParameterInvalidException,
-            self.hda_deserializer.deserialize, self.trans, hda, data={ 'name': True } )
+            self.hda_deserializer.deserialize, hda, { 'name': True } )
         self.log( 'should raise when deserializing from None' )
         self.assertRaises( exceptions.RequestParameterInvalidException,
-            self.hda_deserializer.deserialize, self.trans, hda, data={ 'name': None } )
+            self.hda_deserializer.deserialize, hda, { 'name': None } )
         # self.log( 'should deserialize to empty string from None' )
-        # self.hda_deserializer.deserialize( self.trans, hda, data={ 'name': None } )
+        # self.hda_deserializer.deserialize( hda, { 'name': None } )
         # self.assertEqual( hda.name, '' )
         self.log( 'should be able to deserialize from unicode' )
         olive = u'ελιά'
-        self.hda_deserializer.deserialize( self.trans, hda, data={ 'name': olive } )
+        self.hda_deserializer.deserialize( hda, { 'name': olive } )
         self.assertEqual( hda.name, olive )
         self.log( 'should be deserializable from empty string' )
-        self.hda_deserializer.deserialize( self.trans, hda, data={ 'name': '' } )
+        self.hda_deserializer.deserialize( hda, { 'name': '' } )
         self.assertEqual( hda.name, '' )
 
     def test_deserialize_info( self ):
@@ -531,16 +531,16 @@ class HDADeserializerTestCase( HDATestCase ):
 
         self.log( 'should raise when deserializing from non-string' )
         self.assertRaises( exceptions.RequestParameterInvalidException,
-            self.hda_deserializer.deserialize, self.trans, hda, data={ 'info': True } )
+            self.hda_deserializer.deserialize, hda, { 'info': True } )
         self.log( 'should raise when deserializing from None' )
         self.assertRaises( exceptions.RequestParameterInvalidException,
-            self.hda_deserializer.deserialize, self.trans, hda, data={ 'info': None } )
+            self.hda_deserializer.deserialize, hda, { 'info': None } )
         self.log( 'should be able to deserialize from unicode' )
         rice = u'飯'
-        self.hda_deserializer.deserialize( self.trans, hda, data={ 'info': rice } )
+        self.hda_deserializer.deserialize( hda, { 'info': rice } )
         self.assertEqual( hda.info, rice )
         self.log( 'should be deserializable from empty string' )
-        self.hda_deserializer.deserialize( self.trans, hda, data={ 'info': '' } )
+        self.hda_deserializer.deserialize( hda, { 'info': '' } )
         self.assertEqual( hda.info, '' )
 
 

test/unit/managers/test_HistoryManager.py

@@ -331,15 +331,15 @@ class HistorySerializerTestCase( BaseTestCase ):
         history1 = self.history_manager.create( name='history1', user=user2 )
 
         self.log( 'should have a summary view' )
-        summary_view = self.history_serializer.serialize_to_view( self.trans, history1, view='summary' )
+        summary_view = self.history_serializer.serialize_to_view( history1, view='summary' )
         self.assertKeys( summary_view, self.history_serializer.views[ 'summary' ] )
 
         self.log( 'should have a detailed view' )
-        detailed_view = self.history_serializer.serialize_to_view( self.trans, history1, view='detailed' )
+        detailed_view = self.history_serializer.serialize_to_view( history1, view='detailed' )
         self.assertKeys( detailed_view, self.history_serializer.views[ 'detailed' ] )
 
         self.log( 'should have the summary view as default view' )
-        default_view = self.history_serializer.serialize_to_view( self.trans, history1, default_view='summary' )
+        default_view = self.history_serializer.serialize_to_view( history1, default_view='summary' )
         self.assertKeys( summary_view, self.history_serializer.views[ 'summary' ] )
 
         self.log( 'should have a serializer for all serializable keys' )
@@ -356,13 +356,13 @@ class HistorySerializerTestCase( BaseTestCase ):
         history1 = self.history_manager.create( name='history1', user=user2 )
 
         self.log( 'should be able to use keys with views' )
-        serialized = self.history_serializer.serialize_to_view( self.trans, history1,
+        serialized = self.history_serializer.serialize_to_view( history1,
             view='summary', keys=[ 'state_ids', 'user_id' ] )
         self.assertKeys( serialized,
             self.history_serializer.views[ 'summary' ] + [ 'state_ids', 'user_id' ] )
 
         self.log( 'should be able to use keys on their own' )
-        serialized = self.history_serializer.serialize_to_view( self.trans, history1,
+        serialized = self.history_serializer.serialize_to_view( history1,
             keys=[ 'state_ids', 'user_id' ] )
         self.assertKeys( serialized, [ 'state_ids', 'user_id' ] )
 
@@ -372,7 +372,7 @@ class HistorySerializerTestCase( BaseTestCase ):
 
         self.log( 'should have a serializer for all SharableModel keys' )
         sharable_attrs = [ 'user_id', 'username_and_slug', 'importable', 'published', 'slug' ]
-        serialized = self.history_serializer.serialize( self.trans, history1, sharable_attrs )
+        serialized = self.history_serializer.serialize( history1, sharable_attrs )
         self.assertKeys( serialized, sharable_attrs )
 
     def test_purgable( self ):
@@ -381,18 +381,18 @@ class HistorySerializerTestCase( BaseTestCase ):
 
         self.log( 'deleted and purged should be returned in their default states' )
         keys = [ 'deleted', 'purged' ]
-        serialized = self.history_serializer.serialize( self.trans, history1, keys )
+        serialized = self.history_serializer.serialize( history1, keys )
         self.assertEqual( serialized[ 'deleted' ], False )
         self.assertEqual( serialized[ 'purged' ], False )
 
         self.log( 'deleted and purged should return their current state' )
         self.history_manager.delete( history1 )
-        serialized = self.history_serializer.serialize( self.trans, history1, keys )
+        serialized = self.history_serializer.serialize( history1, keys )
         self.assertEqual( serialized[ 'deleted' ], True )
         self.assertEqual( serialized[ 'purged' ], False )
 
         self.history_manager.purge( history1 )
-        serialized = self.history_serializer.serialize( self.trans, history1, keys )
+        serialized = self.history_serializer.serialize( history1, keys )
         self.assertEqual( serialized[ 'deleted' ], True )
         self.assertEqual( serialized[ 'purged' ], True )
 
@@ -400,7 +400,7 @@ class HistorySerializerTestCase( BaseTestCase ):
         user2 = self.user_manager.create( **user2_data )
         history1 = self.history_manager.create( name='history1', user=user2 )
         all_keys = list( self.history_serializer.serializable_keyset )
-        serialized = self.history_serializer.serialize( self.trans, history1, all_keys )
+        serialized = self.history_serializer.serialize( history1, all_keys )
 
         self.log( 'everything serialized should be of the proper type' )
         self.assertIsInstance( serialized[ 'size' ], int )
@@ -415,7 +415,7 @@ class HistorySerializerTestCase( BaseTestCase ):
 
         self.log( 'a history with no contents should be properly reflected in empty, etc.' )
         keys = [ 'empty', 'count', 'state_ids', 'state_details', 'state', 'hdas' ]
-        serialized = self.history_serializer.serialize( self.trans, history1, keys )
+        serialized = self.history_serializer.serialize( history1, keys )
         self.assertEqual( serialized[ 'state' ], 'new' )
         self.assertEqual( serialized[ 'empty' ], True )
         self.assertEqual( serialized[ 'count' ], 0 )
@@ -427,7 +427,7 @@ class HistorySerializerTestCase( BaseTestCase ):
         hda1 = self.hda_manager.create( history=history1, hid=1 )
         self.hda_manager.update( hda1, dict( state='ok' ) )
 
-        serialized = self.history_serializer.serialize( self.trans, history1, keys )
+        serialized = self.history_serializer.serialize( history1, keys )
         self.assertEqual( serialized[ 'state' ], 'ok' )
         self.assertEqual( serialized[ 'empty' ], False )
         self.assertEqual( serialized[ 'count' ], 1 )
@@ -436,7 +436,7 @@ class HistorySerializerTestCase( BaseTestCase ):
         self.assertIsInstance( serialized[ 'hdas' ], list )
         self.assertIsInstance( serialized[ 'hdas' ][0], basestring )
 
-        serialized = self.history_serializer.serialize( self.trans, history1, [ 'contents' ] )
+        serialized = self.history_serializer.serialize( history1, [ 'contents' ] )
         self.assertHasKeys( serialized[ 'contents' ][0], [ 'id', 'name', 'peek', 'create_time' ])
 
         self.log( 'serialized should jsonify well' )

test/unit/managers/test_UserManager.py

@@ -142,11 +142,11 @@ class UserSerializerTestCase( BaseTestCase ):
         user = self.user_manager.create( **user2_data )
 
         self.log( 'should have a summary view' )
-        summary_view = self.user_serializer.serialize_to_view( self.trans, user, view='summary' )
+        summary_view = self.user_serializer.serialize_to_view( user, view='summary' )
         self.assertKeys( summary_view, self.user_serializer.views[ 'summary' ] )
 
         self.log( 'should have the summary view as default view' )
-        default_view = self.user_serializer.serialize_to_view( self.trans, user, default_view='summary' )
+        default_view = self.user_serializer.serialize_to_view( user, default_view='summary' )
         self.assertKeys( summary_view, self.user_serializer.views[ 'summary' ] )
 
         self.log( 'should have a serializer for all serializable keys' )
@@ -162,20 +162,20 @@ class UserSerializerTestCase( BaseTestCase ):
         user = self.user_manager.create( **user2_data )
 
         self.log( 'should be able to use keys with views' )
-        serialized = self.user_serializer.serialize_to_view( self.trans, user,
+        serialized = self.user_serializer.serialize_to_view( user,
             view='summary', keys=[ 'create_time' ] )
         self.assertKeys( serialized,
             self.user_serializer.views[ 'summary' ] + [ 'create_time' ] )
 
         self.log( 'should be able to use keys on their own' )
-        serialized = self.user_serializer.serialize_to_view( self.trans, user,
+        serialized = self.user_serializer.serialize_to_view( user,
             keys=[ 'tags_used', 'is_admin' ] )
         self.assertKeys( serialized, [ 'tags_used', 'is_admin' ] )
 
     def test_serializers( self ):
         user = self.user_manager.create( **user2_data )
         all_keys = list( self.user_serializer.serializable_keyset )
-        serialized = self.user_serializer.serialize( self.trans, user, all_keys )
+        serialized = self.user_serializer.serialize( user, all_keys, trans=self.trans )
         # pprint.pprint( serialized )
 
         self.log( 'everything serialized should be of the proper type' )
@@ -207,10 +207,10 @@ class CurrentUserSerializerTestCase( BaseTestCase ):
     def test_anonymous( self ):
         anonym = None
         # need a history here for total_disk_usage
-        self.trans.set_history( self.history_manager.create( self.trans ) )
+        self.trans.set_history( self.history_manager.create() )
 
         self.log( 'should be able to serialize anonymous user' )
-        serialized = self.user_serializer.serialize_to_view( self.trans, anonym, view='detailed' )
+        serialized = self.user_serializer.serialize_to_view( anonym, view='detailed', trans=self.trans )
         self.assertKeys( serialized,
             [ 'id', 'total_disk_usage', 'nice_total_disk_usage', 'quota_percent' ] )