c.lines_added = 0  # count of lines added

        c.lines_deleted = 0  # count of lines removes

        cumulative_diff = 0

        c.cut_off = False  # defines if cut off limit is reached

        c.changeset_statuses = ChangesetStatus.STATUSES

        c.comments = []

        c.statuses = []

        c.inline_comments = []

        c.inline_cnt = 0

        # Iterate over ranges (default changeset view is always one changeset)

        for changeset in c.cs_ranges:

            c.statuses.extend([ChangesetStatusModel()\

                              .get_status(c.rhodecode_db_repo.repo_id,

                                          changeset.raw_id)])

            c.comments.extend(ChangesetCommentsModel()\

                              .get_comments(c.rhodecode_db_repo.repo_id,

                                            revision=changeset.raw_id))

            inlines = ChangesetCommentsModel()\

                        .get_inline_comments(c.rhodecode_db_repo.repo_id,

                                             revision=changeset.raw_id)

            c.inline_comments.extend(inlines)

            c.changes[changeset.raw_id] = []

            try:

                changeset_parent = changeset.parents[0]

            except IndexError:

                changeset_parent = None

            #==================================================================

            # ADDED FILES

            #==================================================================

            for node in changeset.added:

                fid = h.FID(revision, node.path)

                line_context_lcl = get_line_ctx(fid, request.GET)

                ign_whitespace_lcl = get_ignore_ws(fid, request.GET)

                lim = self.cut_off_limit

                if cumulative_diff > self.cut_off_limit:

                    lim = -1 if limit_off is None else None

                size, cs1, cs2, diff, st = wrapped_diff(

                    filenode_old=None,

                    filenode_new=node,

                    cut_off_limit=lim,

                    ignore_whitespace=ign_whitespace_lcl,

                    line_context=line_context_lcl,

                    enable_comments=enable_comments

                )

                cumulative_diff += size

                c.lines_added += st[0]

                c.lines_deleted += st[1]

                c.changes[changeset.raw_id].append(

                    ('added', node, diff, cs1, cs2, st)

                )

            #==================================================================

            # CHANGED FILES

            #==================================================================

            for node in changeset.changed:

                try:

                    filenode_old = changeset_parent.get_node(node.path)

                except ChangesetError:

                    log.warning('Unable to fetch parent node for diff')

                    filenode_old = FileNode(node.path, '', EmptyChangeset())

                fid = h.FID(revision, node.path)

                line_context_lcl = get_line_ctx(fid, request.GET)

                ign_whitespace_lcl = get_ignore_ws(fid, request.GET)

                lim = self.cut_off_limit

                if cumulative_diff > self.cut_off_limit:

                    lim = -1 if limit_off is None else None

                size, cs1, cs2, diff, st = wrapped_diff(

                    filenode_old=filenode_old,

                    filenode_new=node,

                    cut_off_limit=lim,

                    ignore_whitespace=ign_whitespace_lcl,

                    line_context=line_context_lcl,

                    enable_comments=enable_comments

                )

                cumulative_diff += size

                c.lines_added += st[0]

                c.lines_deleted += st[1]

                c.changes[changeset.raw_id].append(

                    ('changed', node, diff, cs1, cs2, st)

                )

            #==================================================================

            # REMOVED FILES

            #==================================================================

            for node in changeset.removed:

                c.changes[changeset.raw_id].append(

                    ('removed', node, None, None, None, (0, 0))

                )

        # count inline comments

        for __, lines in c.inline_comments:

            for comments in lines.values():

                c.inline_cnt += len(comments)

        if len(c.cs_ranges) == 1:

            c.changeset = c.cs_ranges[0]

            c.changes = c.changes[c.changeset.raw_id]

            return render('changeset/changeset.html')

        else:

            return render('changeset/changeset_range.html')

    def raw_changeset(self, revision):

        method = request.GET.get('diff', 'show')

        ignore_whitespace = request.GET.get('ignorews') == '1'

        line_context = request.GET.get('context', 3)

        try:

            c.scm_type = c.rhodecode_repo.alias

            c.changeset = c.rhodecode_repo.get_changeset(revision)

        except RepositoryError:

            log.error(traceback.format_exc())

            return redirect(url('home'))

        else:

            try:

                c.changeset_parent = c.changeset.parents[0]

            except IndexError:

                c.changeset_parent = None

            c.changes = []

            for node in c.changeset.added:

                filenode_old = FileNode(node.path, '')

                if filenode_old.is_binary or node.is_binary:

                    diff = _('binary file') + '\n'

                else:

                    f_gitdiff = diffs.get_gitdiff(filenode_old, node,

                                           ignore_whitespace=ignore_whitespace,

                                           context=line_context)

                    diff = diffs.DiffProcessor(f_gitdiff,

                                                format='gitdiff').raw_diff()

                cs1 = None

                cs2 = node.changeset.raw_id

                c.changes.append(('added', node, diff, cs1, cs2))

            for node in c.changeset.changed:

                filenode_old = c.changeset_parent.get_node(node.path)

                if filenode_old.is_binary or node.is_binary:

                    diff = _('binary file')

                else:

                    f_gitdiff = diffs.get_gitdiff(filenode_old, node,

                                           ignore_whitespace=ignore_whitespace,

                                           context=line_context)

                    diff = diffs.DiffProcessor(f_gitdiff,

                                                format='gitdiff').raw_diff()

                cs1 = filenode_old.changeset.raw_id

                cs2 = node.changeset.raw_id

                c.changes.append(('changed', node, diff, cs1, cs2))

        response.content_type = 'text/plain'

        if method == 'download':

            response.content_disposition = 'attachment; filename=%s.patch' \

                                            % revision

        c.parent_tmpl = ''.join(['# Parent  %s\n' % x.raw_id

                                 for x in c.changeset.parents])

        c.diffs = ''

        for x in c.changes:

            c.diffs += x[2]

        return render('changeset/raw_changeset.html')

    @jsonify

    def comment(self, repo_name, revision):

        status = request.POST.get('changeset_status')

        change_status = request.POST.get('change_changeset_status')

        text = request.POST.get('text')

        if status and change_status:

            text = text or (_('Status change -> %s')

                            % ChangesetStatus.get_status_lbl(status))

        comm = ChangesetCommentsModel().create(

            text=text,

            repo=c.rhodecode_db_repo.repo_id,

            user=c.rhodecode_user.user_id,

            revision=revision,

            f_path=request.POST.get('f_path'),

            line_no=request.POST.get('line'),

            status_change=(ChangesetStatus.get_status_lbl(status)

                           if status and change_status else None)

        )

        # get status if set !

        if status and change_status:

            # if latest status was from pull request and it's closed

            # dont_allow_on_closed_pull_request = True !

            try:

                ChangesetStatusModel().set_status(

                    c.rhodecode_db_repo.repo_id,

                    status,

                    c.rhodecode_user.user_id,

                    comm,

                    revision=revision,

                    dont_allow_on_closed_pull_request=True

                )

            except StatusChangeOnClosedPullRequestError:

                log.error(traceback.format_exc())

                msg = _('Changing status on a changeset associated with'

                        'a closed pull request is not allowed')

                h.flash(msg, category='warning')

                return redirect(h.url('changeset_home', repo_name=repo_name,

                                      revision=revision))

        action_logger(self.rhodecode_user,

                      'user_commented_revision:%s' % revision,

                      c.rhodecode_db_repo, self.ip_addr, self.sa)

        Session().commit()

        if not request.environ.get('HTTP_X_PARTIAL_XHR'):

            return redirect(h.url('changeset_home', repo_name=repo_name,

                                  revision=revision))

        data = {

           'target_id': h.safeid(h.safe_unicode(request.POST.get('f_path'))),

        }

        if comm:

            c.co = comm

            data.update(comm.get_dict())

            data.update({'rendered_text':

                         render('changeset/changeset_comment_block.html')})

        return data

    @jsonify

    def delete_comment(self, repo_name, comment_id):

        co = ChangesetComment.get(comment_id)

        owner = lambda: co.author.user_id == c.rhodecode_user.user_id

        if h.HasPermissionAny('hg.admin', 'repository.admin')() or owner:

            ChangesetCommentsModel().delete(comment=co)

            Session().commit()

            return True

        else:

            raise HTTPForbidden()

# BytesIO

#==============================================================================

try:

    from io import BytesIO

except ImportError:

    from cStringIO import StringIO as BytesIO

#==============================================================================

# bytes

#==============================================================================

if __py_version__ >= (2, 6):

    _bytes = bytes

else:

    # in py2.6 bytes is a synonim for str

    _bytes = str

#==============================================================================

# deque

#==============================================================================

if __py_version__ >= (2, 6):

    from collections import deque

else:

    #need to implement our own deque with maxlen

    class deque(object):

        def __init__(self, iterable=(), maxlen= -1):

            if not hasattr(self, 'data'):

                self.left = self.right = 0

                self.data = {}

            self.maxlen = maxlen or -1

            self.extend(iterable)

        def append(self, x):

            self.data[self.right] = x

            self.right += 1

            if self.maxlen != -1 and len(self) > self.maxlen:

                self.popleft()

        def appendleft(self, x):

            self.left -= 1

            self.data[self.left] = x

            if self.maxlen != -1 and len(self) > self.maxlen:

                self.pop()

        def pop(self):

            if self.left == self.right:

                raise IndexError('cannot pop from empty deque')

            self.right -= 1

            elem = self.data[self.right]

            del self.data[self.right]

            return elem

        def popleft(self):

            if self.left == self.right:

                raise IndexError('cannot pop from empty deque')

            elem = self.data[self.left]

            del self.data[self.left]

            self.left += 1

            return elem

        def clear(self):

            self.data.clear()

            self.left = self.right = 0

        def extend(self, iterable):

            for elem in iterable:

                self.append(elem)

        def extendleft(self, iterable):

            for elem in iterable:

                self.appendleft(elem)

        def rotate(self, n=1):

            if self:

                n %= len(self)

                for i in xrange(n):

                    self.appendleft(self.pop())

        def __getitem__(self, i):

            if i < 0:

                i += len(self)

            try:

                return self.data[i + self.left]

            except KeyError:

                raise IndexError

        def __setitem__(self, i, value):

            if i < 0:

                i += len(self)

            try:

                self.data[i + self.left] = value

            except KeyError:

                raise IndexError

        def __delitem__(self, i):

            size = len(self)

            if not (-size <= i < size):

                raise IndexError

            data = self.data

            if i < 0:

                i += size

            for j in xrange(self.left + i, self.right - 1):

                data[j] = data[j + 1]

            self.pop()

        def __len__(self):

            return self.right - self.left

        def __cmp__(self, other):

            if type(self) != type(other):

                return cmp(type(self), type(other))

            return cmp(list(self), list(other))

        def __repr__(self, _track=[]):

            if id(self) in _track:

                return '...'

            _track.append(id(self))

            r = 'deque(%r, maxlen=%s)' % (list(self), self.maxlen)

            _track.remove(id(self))

            return r

        def __getstate__(self):

            return (tuple(self),)

        def __setstate__(self, s):

            self.__init__(s[0])

        def __hash__(self):

            raise TypeError

        def __copy__(self):

            return self.__class__(self)

        def __deepcopy__(self, memo={}):

            from copy import deepcopy

            result = self.__class__()

            memo[id(self)] = result

            result.__init__(deepcopy(tuple(self), memo))

            return result

#==============================================================================

# threading.Event

#==============================================================================

if __py_version__ >= (2, 6):

    from threading import Event, Thread

else:

    from threading import _Verbose, Condition, Lock, Thread

    def Event(*args, **kwargs):

        return _Event(*args, **kwargs)

    class _Event(_Verbose):

        # After Tim Peters' event class (without is_posted())

        def __init__(self, verbose=None):

            _Verbose.__init__(self, verbose)

            self.__cond = Condition(Lock())

            self.__flag = False

        def isSet(self):

            return self.__flag

        is_set = isSet

        def set(self):

            self.__cond.acquire()

            try:

                self.__flag = True

                self.__cond.notify_all()

            finally:

                self.__cond.release()

        def clear(self):

            self.__cond.acquire()

            try:

                self.__flag = False

            finally:

                self.__cond.release()

        def wait(self, timeout=None):

            self.__cond.acquire()

            try:

                if not self.__flag:

                    self.__cond.wait(timeout)

            finally:

                self.__cond.release()

        """

        Returns Invalidation object if this given key should be invalidated

        None otherwise. `cache_active = False` means that this cache

        state is not valid and needs to be invalidated

        :param key:

        """

        key, _prefix, _org_key = cls._get_key(key)

        inv = cls._get_or_create_key(key, _prefix, _org_key)

        if inv and inv.cache_active is False:

            return inv

    @classmethod

    def set_invalidate(cls, key):

        """

        Mark this Cache key for invalidation

        :param key:

        """

        key, _prefix, _org_key = cls._get_key(key)

        inv_objs = Session.query(cls).filter(cls.cache_args == _org_key).all()

        log.debug('marking %s key[s] %s for invalidation' % (len(inv_objs),

                                                             _org_key))

        try:

            for inv_obj in inv_objs:

                if inv_obj:

                    inv_obj.cache_active = False

                Session.add(inv_obj)

            Session.commit()

        except Exception:

            log.error(traceback.format_exc())

            Session.rollback()

    @classmethod

    def set_valid(cls, key):

        """

        Mark this cache key as active and currently cached

        :param key:

        """

        inv_obj = cls.get_by_key(key)

        inv_obj.cache_active = True

        Session.add(inv_obj)

        Session.commit()

class ChangesetComment(Base, BaseModel):

    __tablename__ = 'changeset_comments'

    __table_args__ = (

        {'extend_existing': True, 'mysql_engine':'InnoDB',

         'mysql_charset': 'utf8'},

    )

    comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)

    repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)

    revision = Column('revision', String(40), nullable=False)

    line_no = Column('line_no', Unicode(10), nullable=True)

    f_path = Column('f_path', Unicode(1000), nullable=True)

    user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)

    text = Column('text', Unicode(25000), nullable=False)

    modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now)

    author = relationship('User', lazy='joined')

    repo = relationship('Repository')

    @classmethod

    def get_users(cls, revision):

        """

        Returns user associated with this changesetComment. ie those

        who actually commented

        :param cls:

        :param revision:

        """

        return Session.query(User)\

                .filter(cls.revision == revision)\

                .join(ChangesetComment.author).all()

class Notification(Base, BaseModel):

    __tablename__ = 'notifications'

    __table_args__ = (

        {'extend_existing': True, 'mysql_engine':'InnoDB',

         'mysql_charset': 'utf8'},

    )

    TYPE_CHANGESET_COMMENT = u'cs_comment'

    TYPE_MESSAGE = u'message'

    TYPE_MENTION = u'mention'

    TYPE_REGISTRATION = u'registration'

    notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True)

    subject = Column('subject', Unicode(512), nullable=True)

    body = Column('body', Unicode(50000), nullable=True)

    created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True)

    created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    type_ = Column('type', Unicode(256))

    created_by_user = relationship('User')

    notifications_to_users = relationship('UserNotification', lazy='joined',

                                          cascade="all, delete, delete-orphan")

    @property

    def recipients(self):

        return [x.user for x in UserNotification.query()\

                .filter(UserNotification.notification == self).all()]

    @classmethod

    def create(cls, created_by, subject, body, recipients, type_=None):

        if type_ is None:

            type_ = Notification.TYPE_MESSAGE

        notification = cls()

        notification.created_by_user = created_by

        notification.subject = subject

        notification.body = body

        notification.type_ = type_

        notification.created_on = datetime.datetime.now()

        for u in recipients:

            assoc = UserNotification()

            assoc.notification = notification

            u.notifications.append(assoc)

        Session.add(notification)

        return notification

    @property

    def description(self):

        from rhodecode.model.notification import NotificationModel

        return NotificationModel().make_description(self)

class UserNotification(Base, BaseModel):

    __tablename__ = 'user_to_notification'

    __table_args__ = (

        UniqueConstraint('user_id', 'notification_id'),

        {'extend_existing': True, 'mysql_engine':'InnoDB',

         'mysql_charset': 'utf8'}

    )

    user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)

    notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True)

    read = Column('read', Boolean, default=False)

    sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)

    user = relationship('User', lazy="joined")

    notification = relationship('Notification', lazy="joined",

                                order_by=lambda: Notification.created_on.desc(),)

    def mark_as_read(self):

        self.read = True

        Session.add(self)

class DbMigrateVersion(Base, BaseModel):

    __tablename__ = 'db_migrate_version'

    __table_args__ = (

        {'extend_existing': True, 'mysql_engine':'InnoDB',

         'mysql_charset': 'utf8'},

    )

    repository_id = Column('repository_id', String(250), primary_key=True)

    repository_path = Column('repository_path', Text)

    version = Column('version', Integer)

## this is migration from 1_4_0, but now it's here to overcome a problem of

## attaching a FK to this from 1_3_0 !

class PullRequest(Base, BaseModel):

    __tablename__ = 'pull_requests'

    __table_args__ = (

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8'},

    )

    STATUS_NEW = u'new'

    STATUS_OPEN = u'open'

    STATUS_CLOSED = u'closed'

    pull_request_id = Column('pull_request_id', Integer(), nullable=False, primary_key=True)

    title = Column('title', Unicode(256), nullable=True)

    description = Column('description', UnicodeText(10240), nullable=True)

    status = Column('status', Unicode(256), nullable=False, default=STATUS_NEW)

    created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    updated_on = Column('updated_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None)

    _revisions = Column('revisions', UnicodeText(20500))  # 500 revisions max

    org_repo_id = Column('org_repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)

    org_ref = Column('org_ref', Unicode(256), nullable=False)

    other_repo_id = Column('other_repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)

import logging

import datetime

from sqlalchemy import *

from sqlalchemy.exc import DatabaseError

from sqlalchemy.orm import relation, backref, class_mapper

from sqlalchemy.orm.session import Session

from sqlalchemy.ext.declarative import declarative_base

from rhodecode.lib.dbmigrate.migrate import *

from rhodecode.lib.dbmigrate.migrate.changeset import *

from rhodecode.model.meta import Base

from rhodecode.model import meta

log = logging.getLogger(__name__)

def upgrade(migrate_engine):

    """

    Upgrade operations go here.

    Don't create your own engine; bind migrate_engine to your metadata

    """

    #==========================================================================

    # USEREMAILMAP

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_4_0 import UserEmailMap

    tbl = UserEmailMap.__table__

    tbl.create()

    #==========================================================================

    # PULL REQUEST

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_4_0 import PullRequest

    tbl = PullRequest.__table__

    tbl.create()

    #==========================================================================

    # PULL REQUEST REVIEWERS

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_4_0 import PullRequestReviewers

    tbl = PullRequestReviewers.__table__

    tbl.create()

    #==========================================================================

    # CHANGESET STATUS

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_4_0 import ChangesetStatus

    tbl = ChangesetStatus.__table__

    tbl.create()

    Base = declarative_base()

    Base.metadata.clear()

    Base.metadata = MetaData()

    Base.metadata.bind = migrate_engine

    meta.Base = Base

    #==========================================================================

    # USERS TABLE

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import User

    tbl = User.__table__

    # change column name -> firstname

    col = User.__table__.columns.name

    col.alter(index=Index('u_username_idx', 'username'))

    col.alter(index=Index('u_email_idx', 'email'))

    col.alter(name="firstname", table=tbl)

    # add inherit_default_permission column

    inherit_default_permissions = Column("inherit_default_permissions",

                                         Boolean(), nullable=True, unique=None,

                                         default=True)

    inherit_default_permissions.create(table=tbl)

    inherit_default_permissions.alter(nullable=False, default=True, table=tbl)

    #==========================================================================

    # USERS GROUP TABLE

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import UsersGroup

    tbl = UsersGroup.__table__

    # add inherit_default_permission column

    gr_inherit_default_permissions = Column(

                                    "users_group_inherit_default_permissions",

                                    Boolean(), nullable=True, unique=None,

                                    default=True)

    gr_inherit_default_permissions.create(table=tbl)

    gr_inherit_default_permissions.alter(nullable=False, default=True, table=tbl)

    #==========================================================================

    # REPOSITORIES

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import Repository

    tbl = Repository.__table__

    # add enable locking column

    enable_locking = Column("enable_locking", Boolean(), nullable=True,

                            unique=None, default=False)

    enable_locking.create(table=tbl)

    enable_locking.alter(nullable=False, default=False, table=tbl)

    # add locked column

    _locked = Column("locked", String(255), nullable=True, unique=False,

                     default=None)

    _locked.create(table=tbl)

    #add langing revision column

    landing_rev = Column("landing_revision", String(255), nullable=True,

                         unique=False, default='tip')

    landing_rev.create(table=tbl)

    landing_rev.alter(nullable=False, default='tip', table=tbl)

    #==========================================================================

    # GROUPS

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import RepoGroup

    tbl = RepoGroup.__table__

    # add enable locking column

    enable_locking = Column("enable_locking", Boolean(), nullable=True,

                            unique=None, default=False)

    enable_locking.create(table=tbl)

    enable_locking.alter(nullable=False, default=False)

    #==========================================================================

    # CACHE INVALIDATION

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import CacheInvalidation

    tbl = CacheInvalidation.__table__

    # add INDEX for cache keys

    col = CacheInvalidation.__table__.columns.cache_key

    col.alter(index=Index('key_idx', 'cache_key'))

    #==========================================================================

    # NOTIFICATION

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import Notification

    tbl = Notification.__table__

    # add index for notification type

    col = Notification.__table__.columns.type

    col.alter(index=Index('notification_type_idx', 'type'),)

    #==========================================================================

    # CHANGESET_COMMENTS

    #==========================================================================

    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import ChangesetComment

    tbl = ChangesetComment.__table__

    col = ChangesetComment.__table__.columns.revision

    # add index for revisions

    col.alter(index=Index('cc_revision_idx', 'revision'),)

    # add hl_lines column

    hl_lines = Column('hl_lines', Unicode(512), nullable=True)

    hl_lines.create(table=tbl)

    # add created_on column

    created_on = Column('created_on', DateTime(timezone=False), nullable=True,

                        default=datetime.datetime.now)

    created_on.create(table=tbl)

    created_on.alter(nullable=False, default=datetime.datetime.now)

    modified_at = Column('modified_at', DateTime(timezone=False), nullable=False,

                         default=datetime.datetime.now)

    modified_at.alter(type=DateTime(timezone=False), table=tbl)

    # add FK to pull_request

    pull_request_id = Column("pull_request_id", Integer(),

                             ForeignKey('pull_requests.pull_request_id'),

                             nullable=True)

    pull_request_id.create(table=tbl)

    ## RESET COMPLETLY THE metadata for sqlalchemy back after using 1_3_0

    Base = declarative_base()

    Base.metadata.clear()

    Base.metadata = MetaData()

    Base.metadata.bind = migrate_engine

    meta.Base = Base

def downgrade(migrate_engine):

    meta = MetaData()

    meta.bind = migrate_engine

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import os

import re

import logging

import datetime

import traceback

import paste

import beaker

import tarfile

import shutil

from os.path import abspath

from os.path import dirname as dn, join as jn

from paste.script.command import Command, BadCommand

from mercurial import ui, config