def take_action(self, opts):
        #Work-around for SQLA0.8 being incompatible with sqlalchemy-migrate
        import sqlalchemy
        sqlalchemy.exceptions = sqlalchemy.exc

        from migrate.versioning.shell import main

        sect = 'app:main'
        option = 'sqlalchemy.url'

        # get sqlalchemy.url config in app:mains
        conf = ConfigParser()
        conf.read(opts.ini)

        name = "migration"
        try:
            dburi = conf.get(sect, option, vars={'here':os.getcwd()})
        except:
            print("Unable to read config file or missing sqlalchemy.url in app:main section")
            return

        print("Migrations repository '%s',\ndatabase url '%s'\n"%(name, dburi))
        if not opts.args:
            opts.args = ['help']
        sys.argv[0] = sys.argv[0] + ' migrate'
        main(argv=opts.args, url=dburi, repository=name, name=name)

def invoke_migrate_main():
    # Migrate has its own args, so cannot use argparse
    config = get_config(sys.argv, use_argparse=False)
    db_url = config['db_url']
    repo = config['repo']

    main(repository=repo, url=db_url)

 def parseOptions(self, options=None):
     if not required_imports_ok():
         sys.exit(1)
     from migrate.versioning.shell import main
     # Tweak sys.argv
     sys.argv = sys.argv[sys.argv.index('migrate'):]
     main(url=db.create_engine().url, repository=UPGRADES_REPO.path)
     sys.exit()

        def handle(self, app, prog, name, remaining_args):
            optional = {}
            repository = app.config.get('SQLALCHEMY_MIGRATE_REPOSITORY', False)
            if repository:
                optional['repository'] = repository

            shell.main(remaining_args,
                       url=app.config['SQLALCHEMY_DATABASE_URI'],
                       debug=app.config['DEBUG'],
                       **optional)

 def _check_error(self,args,code,expected,**kw):
     original = sys.stderr
     try:
         actual = StringIO()
         sys.stderr = actual
         try:
             shell.main(args,**kw)
         except SystemExit, e:
             self.assertEqual(code,e.args[0])
         else:

    def test_shutdown_logging(self):
        """Try to shutdown logging output"""
        repos = self.tmp_repos()
        result = self.env.run('migrate create %s repository_name' % repos)
        result = self.env.run('migrate version %s --disable_logging' % repos)
        self.assertEqual(result.stdout, '')
        result = self.env.run('migrate version %s -q' % repos)
        self.assertEqual(result.stdout, '')

        # TODO: assert logging messages to 0
        shell.main(['version', repos], logging=False)

def main(url, repository):
    # Check if database is under version control
    try:
        db_version(url, repository)
    except DatabaseNotControlledError:
        # put database under version control
        version_control(url, repository)         

    kwargs = {'url': url,
        'repository': repository
    }

    shell.main(**kwargs)

    def test_main(self):
        """Test main() function"""
        repos = self.tmp_repos()
        shell.main(['help'])
        shell.main(['help', 'create'])
        shell.main(['create', 'repo_name', '--preview_sql'], repository=repos)
        shell.main(['version', '--', '--repository=%s' % repos])
        shell.main(['version', '-d', '--repository=%s' % repos, '--version=2'])

        self._check_error(['foobar'],2,'error: Invalid command foobar')
        self._check_error(['create', 'f', 'o', 'o'],2,'error: Too many arguments for command create: o')
        self._check_error(['create'],2,'error: Not enough arguments for command create: name, repository not specified')
        self._check_error(['create', 'repo_name'],2,'already exists', repository=repos)

    def test_main(self):
        """Test main() function"""
        repos = self.tmp_repos()
        shell.main(["help"])
        shell.main(["help", "create"])
        shell.main(["create", "repo_name", "--preview_sql"], repository=repos)
        shell.main(["version", "--", "--repository=%s" % repos])
        shell.main(["version", "-d", "--repository=%s" % repos, "--version=2"])

        self._check_error(["foobar"], 2, "error: Invalid command foobar")
        self._check_error(["create", "f", "o", "o"], 2, "error: Too many arguments for command create: o")
        self._check_error(
            ["create"], 2, "error: Not enough arguments for command create: name, repository not specified"
        )
        self._check_error(["create", "repo_name"], 2, "already exists", repository=repos)

 def _check_error(self,args,code,expected,**kw):
     original = sys.stderr
     try:
         actual = cStringIO()
         sys.stderr = actual
         try:
             shell.main(args,**kw)
         except SystemExit as e:
             self.assertEqual(code,e.args[0])
         else:
             self.fail('No exception raised')
     finally:
         sys.stderr = original
     actual = actual.getvalue()
     self.assertTrue(expected in actual,'%r not in:\n"""\n%s\n"""'%(expected,actual))

def setup_schema(command, conf, vars):
    """Place any commands to setup tutorial here"""
    # Load the models

    # <websetup.websetup.schema.before.model.import>
    from tutorial import model
    # <websetup.websetup.schema.after.model.import>

    
    # <websetup.websetup.schema.before.metadata.create_all>
    print "Creating tables"
    model.metadata.create_all(bind=config['pylons.app_globals'].sa_engine)
    # <websetup.websetup.schema.after.metadata.create_all>
    transaction.commit()
    from migrate.versioning.shell import main
    main(argv=['version_control'], url=config['sqlalchemy.url'], repository='migration', name='migration')

    def _perform_appless_action(self, pluggable):
        repository = self._pluggable_repository(pluggable)
        if repository is None:
            return

        tablename = self._pluggable_tablename(pluggable)
        print "\n%s Migrations" % pluggable
        print "\tRepository '%s'" % repository
        print "\tVersioning Table '%s'" % tablename

        #disable logging, this is due to sqlalchemy-migrate bug that
        #causes the disable_logging option to ignored
        args = self.args[:1] + ['-q'] + self.args[1:]

        main(argv=args, url=None, repository=repository, name=pluggable,
             version_table=tablename, disable_logging=True)

    def command(self):
        ini = 'development.ini'
        sect = 'app:main'
        option = 'sqlalchemy.url'

        # get sqlalchemy.url config in app:mains
        curdir = os.getcwd()
        conf = ConfigParser.ConfigParser()
        conf.read(os.path.join(curdir, ini))

        self.name = "migration"
        try:
            self.dburi = conf.get(sect, option, vars={'here':curdir})
        except:
            print "you shold set sqlalchemy.url in development.ini first"

        print "The repository is '%s'\nThe url is '%s'"%(self.name, self.dburi)
        main(argv=self.args, url=self.dburi,repository=self.name, name=self.name)

    def _perform_migration(self, pluggable):
        repository = self._pluggable_repository(pluggable)
        if repository is None or not os.path.exists(repository):
            print "%s - Pluggable does not support migrations" % pluggable
            return

        tablename = self._pluggable_tablename(pluggable)
        print '\n%s Migrations' % pluggable
        print "\tRepository '%s'" % repository
        print "\tDatabase '%s'" % self.dburi
        print "\tVersioning Table '%s'" % tablename

        #disable logging, this is due to sqlalchemy-migrate bug that
        #causes the disable_logging option to ignored
        args = self.args[:1] + ['-q'] + self.args[1:]

        main(argv=args, url=self.dburi, repository=repository, name=pluggable,
             version_table=tablename, disable_logging=True)

def setup_schema(command, conf, vars):
    """Place any commands to setup tgtodotrack here"""
    # Load the models

    # <websetup.websetup.schema.before.model.import>
    from tgtodotrack import model
    # <websetup.websetup.schema.after.model.import>

    
    # <websetup.websetup.schema.before.metadata.create_all>
    print "Creating tables"
    model.metadata.create_all(bind=config['pylons.app_globals'].sa_engine)
    # <websetup.websetup.schema.after.metadata.create_all>
    transaction.commit()
    from migrate.versioning.shell import main
    from migrate.exceptions import DatabaseAlreadyControlledError
    try:
        main(argv=['version_control'], url=config['sqlalchemy.url'], repository='migration', name='migration')
    except DatabaseAlreadyControlledError:
        print 'Database already under version control'

    def command(self):
        sect = 'app:main'
        option = 'sqlalchemy.url'

        # get sqlalchemy.url config in app:mains
        conf = ConfigParser.ConfigParser()
        conf.read(self.options.ini)

        self.name = "migration"
        try:
            self.dburi = conf.get(sect, option, vars={'here':os.getcwd()})
        except:
            print "Unable to read config file or missing sqlalchemy.url in app:main section"
            return

        print "Migrations repository '%s',\ndatabase url '%s'\n"%(self.name, self.dburi)
        if not self.args:
            self.args = ['help']
        sys.argv[0] = sys.argv[0] + ' migrate'
        main(argv=self.args, url=self.dburi, repository=self.name, name=self.name)

    def take_action(self, opts):
        #Work-around for SQLA0.8 being incompatible with sqlalchemy-migrate
        import sqlalchemy
        sqlalchemy.exceptions = sqlalchemy.exc

        from migrate.versioning.shell import main
        from migrate.exceptions import DatabaseAlreadyControlledError, DatabaseNotControlledError

        self.args = opts.args
        self.options = opts

        if len(self.args) < 2 or self.args[0] == 'help':
            self.args = ['help']
            return main(self.args)

        self._setup_logging()
        name = pkg_resources.safe_name(self.args.pop(0))
        sys.argv[0] = sys.argv[0] + ' migrate'

        if self.args[0] in ('create', 'script'):
            self._perform_appless_action(name)
            return

        # get sqlalchemy.url config in app:mains
        conf = ConfigParser()
        conf.read(opts.ini)

        try:
            sect = 'app:main'
            option = 'sqlalchemy.url'
            self.dburi = conf.get(sect, option, vars={'here':os.getcwd()})
        except:
            print("Unable to read config file or missing sqlalchemy.url in app:main section")
            return

        pluggables_to_migrate = []
        if name == 'all':
            pluggables_to_migrate.extend(self._detect_loaded_pluggables())
        else:
            pluggables_to_migrate.append(name)

        print('Migrating', ', '.join(pluggables_to_migrate))
        for pluggable in pluggables_to_migrate:
            try:
                self._perform_migration(pluggable)
            except DatabaseAlreadyControlledError:
                print('Pluggable already under version control...')
            except DatabaseNotControlledError:
                print('Your application is not under version control for this pluggable')
                print('Please run the version_control command before performing any other action.')

#!/usr/bin/env python
from migrate.versioning.shell import main

if __name__ == '__main__':
    main(six='<module 'six' from '/Users/koki/.virtualenvs/papylus/lib/python2.7/site-packages/six.pyc'>')

#!/usr/bin/env python
from migrate.versioning.shell import main

if __name__ == "__main__":
    main(url="sqlite:///puppies.db", debug="False", repository="puppy_repository")

#!/usr/bin/env python
from migrate.versioning.shell import main
main(url='sqlite:///development.db', debug='False', repository='migrations_repository')