another bunch of import cleans for models

ckan/lib/search/__init__.py

@@ -2,10 +2,9 @@
 from pylons import config, c
 
 from ckan import model
-from ckan.model import DomainObjectOperation
 from ckan.plugins import SingletonPlugin, implements, IDomainObjectModification
 from ckan.logic import get_action
-import ckan.model.domain_object
+import ckan.model.domain_object as domain_object
 
 from common import (SearchIndexError, SearchError, SearchQueryError,
                     make_connection, is_available, SolrSettings)
@@ -59,7 +58,7 @@ def text_traceback():
     _QUERIES['package'] = sql.PackageSearchQuery
 
 def _normalize_type(_type):
-    if isinstance(_type, ckan.model.domain_object.DomainObject):
+    if isinstance(_type, domain_object.DomainObject):
         _type = _type.__class__
     if isinstance(_type, type):
         _type = _type.__name__
@@ -86,11 +85,11 @@ def dispatch_by_operation(entity_type, entity, operation):
     """Call the appropriate index method for a given notification."""
     try:
         index = index_for(entity_type)
-        if operation == DomainObjectOperation.new:
+        if operation == domain_object.DomainObjectOperation.new:
             index.insert_dict(entity)
-        elif operation == DomainObjectOperation.changed:
+        elif operation == domain_object.DomainObjectOperation.changed:
             index.update_dict(entity)
-        elif operation == DomainObjectOperation.deleted:
+        elif operation == domain_object.DomainObjectOperation.deleted:
             index.remove_dict(entity)
         else:
             log.warn("Unknown operation: %s" % operation)
@@ -108,15 +107,15 @@ class SynchronousSearchPlugin(SingletonPlugin):
     def notify(self, entity, operation):
         if not isinstance(entity, model.Package):
             return
-        if operation != DomainObjectOperation.deleted:
+        if operation != domain_object.DomainObjectOperation.deleted:
             dispatch_by_operation(
                 entity.__class__.__name__,
                 get_action('package_show')(
                     {'model': model, 'ignore_auth': True, 'validate': False},
                     {'id': entity.id}),
                 operation
             )
-        elif operation == DomainObjectOperation.deleted:
+        elif operation == domain_object.DomainObjectOperation.deleted:
             dispatch_by_operation(entity.__class__.__name__,
                                   {'id': entity.id}, operation)
         else:

ckan/model/__init__.py

@@ -8,7 +8,7 @@
 from paste.deploy.converters import asbool
 
 import meta
-from domain_object import DomainObjectOperation
+#from domain_object import DomainObjectOperation
 from core import *
 from package import *
 from tag import *

ckan/model/domain_object.py

@@ -5,6 +5,7 @@
 from sqlalchemy.util import OrderedDict
 
 import meta
+import core
 
 class Enum(set):
     '''Simple enumeration
@@ -13,7 +14,7 @@ class Enum(set):
     '''
     def __init__(self, *names):
         super(Enum, self).__init__(names)
-        
+
     def __getattr__(self, name):
         if name in self:
             return name
@@ -23,7 +24,7 @@ def __getattr__(self, name):
 
 # TODO: replace this (or at least inherit from) standard SqlalchemyMixin in vdm
 class DomainObject(object):
-    
+
     text_search_fields = []
     Session = meta.Session
 
@@ -53,8 +54,7 @@ def text_search(cls, query, term):
 
     @classmethod
     def active(cls):
-        from core import State
-        return meta.Session.query(cls).filter_by(state=State.ACTIVE)
+        return meta.Session.query(cls).filter_by(state=core.State.ACTIVE)
 
     def save(self):
         self.add()
@@ -108,7 +108,7 @@ def __unicode__(self):
                 repr += u' %s=%s' % (col.name, getattr(self, col.name))
             except Exception, inst:
                 repr += u' %s=%s' % (col.name, inst)
-                
+
         repr += '>'
         return repr
 

ckan/model/tag.py

@@ -1,9 +1,11 @@
-import sqlalchemy
 import vdm.sqlalchemy
+from sqlalchemy.orm import relation
+from sqlalchemy import types, Column, Table, ForeignKey, and_, UniqueConstraint
 
-from meta import *
-from package import Package
-from core import *
+import package as _package
+import extension as _extension
+import core
+import meta
 import types as _types
 import domain_object
 import vocabulary
@@ -17,24 +19,24 @@
 MAX_TAG_LENGTH = 100
 MIN_TAG_LENGTH = 2
 
-tag_table = Table('tag', metadata,
+tag_table = Table('tag', meta.metadata,
         Column('id', types.UnicodeText, primary_key=True, default=_types.make_uuid),
         Column('name', types.Unicode(MAX_TAG_LENGTH), nullable=False),
         Column('vocabulary_id',
             types.Unicode(vocabulary.VOCABULARY_NAME_MAX_LENGTH),
             ForeignKey('vocabulary.id')),
-        sqlalchemy.UniqueConstraint('name', 'vocabulary_id')
+        UniqueConstraint('name', 'vocabulary_id')
 )
 
-package_tag_table = Table('package_tag', metadata,
+package_tag_table = Table('package_tag', meta.metadata,
         Column('id', types.UnicodeText, primary_key=True, default=_types.make_uuid),
         Column('package_id', types.UnicodeText, ForeignKey('package.id')),
         Column('tag_id', types.UnicodeText, ForeignKey('tag.id')),
         )
 
 vdm.sqlalchemy.make_table_stateful(package_tag_table)
 # TODO: this has a composite primary key ...
-package_tag_revision_table = make_revisioned_table(package_tag_table)
+package_tag_revision_table = core.make_revisioned_table(package_tag_table)
 
 class Tag(domain_object.DomainObject):
     def __init__(self, name='', vocabulary_id=None):
@@ -54,7 +56,7 @@ def by_id(cls, tag_id, autoflush=True):
         tag_id -- The id of the tag to return.
 
         """
-        query = Session.query(Tag).filter(Tag.id==tag_id)
+        query = meta.Session.query(Tag).filter(Tag.id==tag_id)
         query = query.autoflush(autoflush)
         tag = query.first()
         return tag
@@ -75,10 +77,10 @@ def by_name(cls, name, vocab=None, autoflush=True):
 
         """
         if vocab:
-            query = Session.query(Tag).filter(Tag.name==name).filter(
+            query = meta.Session.query(Tag).filter(Tag.name==name).filter(
                 Tag.vocabulary_id==vocab.id)
         else:
-            query = Session.query(Tag).filter(Tag.name==name).filter(
+            query = meta.Session.query(Tag).filter(Tag.name==name).filter(
                 Tag.vocabulary_id==None)
         query = query.autoflush(autoflush)
         tag = query.first()
@@ -132,9 +134,9 @@ def search_by_name(cls, search_term, vocab_id_or_name=None):
             if vocab is None:
                 # The user specified an invalid vocab.
                 return None
-            query = Session.query(Tag).filter(Tag.vocabulary_id==vocab.id)
+            query = meta.Session.query(Tag).filter(Tag.vocabulary_id==vocab.id)
         else:
-            query = Session.query(Tag)
+            query = meta.Session.query(Tag)
         search_term = search_term.strip().lower()
         query = query.filter(Tag.name.contains(search_term))
         query = query.distinct().join(Tag.package_tags)
@@ -155,11 +157,11 @@ def all(cls, vocab_id_or_name=None):
                 # The user specified an invalid vocab.
                 raise ckan.logic.NotFound("could not find vocabulary '%s'"
                         % vocab_id_or_name)
-            query = Session.query(Tag).filter(Tag.vocabulary_id==vocab.id)
+            query = meta.Session.query(Tag).filter(Tag.vocabulary_id==vocab.id)
         else:
-            query = Session.query(Tag).filter(Tag.vocabulary_id == None)
+            query = meta.Session.query(Tag).filter(Tag.vocabulary_id == None)
             query = query.distinct().join(PackageTagRevision)
-            query = query.filter(sqlalchemy.and_(
+            query = query.filter(and_(
                 PackageTagRevision.state == 'active',
                 PackageTagRevision.current == True))
         return query
@@ -171,13 +173,13 @@ def packages(self):
         The list is sorted by package name.
 
         """
-        q = Session.query(Package)
+        q = meta.Session.query(_package.Package)
         q = q.join(PackageTagRevision)
         q = q.filter(PackageTagRevision.tag_id == self.id)
-        q = q.filter(sqlalchemy.and_(
+        q = q.filter(and_(
             PackageTagRevision.state == 'active',
             PackageTagRevision.current == True))
-        q = q.order_by(Package.name)
+        q = q.order_by(_package.Package.name)
         packages = q.all()
         return packages
 
@@ -242,21 +244,21 @@ def by_name(self, package_name, tag_name, vocab_id_or_name=None,
             if vocab is None:
                 # The user specified an invalid vocab.
                 return None
-            query = (Session.query(PackageTag, Tag, Package)
+            query = (meta.Session.query(PackageTag, Tag, _package.Package)
                     .filter(Tag.vocabulary_id == vocab.id)
-                    .filter(Package.name==package_name)
+                    .filter(_package.Package.name==package_name)
                     .filter(Tag.name==tag_name))
         else:
-            query = (Session.query(PackageTag)
-                    .filter(Package.name==package_name)
+            query = (meta.Session.query(PackageTag)
+                    .filter(_package.Package.name==package_name)
                     .filter(Tag.name==tag_name))
         query = query.autoflush(autoflush)
         return query.one()[0]
 
     def related_packages(self):
         return [self.package]
 
-mapper(Tag, tag_table, properties={
+meta.mapper(Tag, tag_table, properties={
     'package_tags': relation(PackageTag, backref='tag',
         cascade='all, delete, delete-orphan',
         ),
@@ -266,21 +268,23 @@ def related_packages(self):
     order_by=tag_table.c.name,
     )
 
-mapper(PackageTag, package_tag_table, properties={
-    'pkg':relation(Package, backref='package_tag_all',
+meta.mapper(PackageTag, package_tag_table, properties={
+    'pkg':relation(_package.Package, backref='package_tag_all',
         cascade='none',
         )
     },
     order_by=package_tag_table.c.id,
     extension=[vdm.sqlalchemy.Revisioner(package_tag_revision_table),
-               extension.PluginMapperExtension(),
+               _extension.PluginMapperExtension(),
                ],
     )
 
-from package_mapping import *
+# FIXME This is very wrong
+# It is part of the circular import crazy
+import package_mapping
 
-vdm.sqlalchemy.modify_base_object_mapper(PackageTag, Revision, State)
-PackageTagRevision = vdm.sqlalchemy.create_object_version(mapper, PackageTag,
+vdm.sqlalchemy.modify_base_object_mapper(PackageTag, core.Revision, core.State)
+PackageTagRevision = vdm.sqlalchemy.create_object_version(meta.mapper, PackageTag,
         package_tag_revision_table)
 
 PackageTagRevision.related_packages = lambda self: [self.continuity.package]

ckan/model/term_translation.py

@@ -1,9 +1,10 @@
-from meta import *
-from core import *
+from sqlalchemy import Column, Table
+from sqlalchemy.types import UnicodeText
+import meta
 
 __all__ = ['term_translation_table']
 
-term_translation_table = Table('term_translation', metadata,
+term_translation_table = Table('term_translation', meta.metadata,
     Column('term', UnicodeText, nullable=False),
     Column('term_translation', UnicodeText, nullable=False),
     Column('lang_code', UnicodeText, nullable=False),