def setup_app_from_commandline(self, argv):
     if len(argv) < 2:
         print >> sys.stderr, 'No configuration file specified.'
         sys.exit(1)
     bootstrap(argv[1])
     self.app = default_app
     return argv[:1] + argv[2:]

def main():
    if len(sys.argv) != 2:
        usage()

    bootstrap(sys.argv[1])

    Base.metadata.create_all()

def main(args=None):
        """The main routine."""
        if args is None:
                args = sys.argv[1:]

        parser = argparse.ArgumentParser(description="Kinto commands")
        subparsers = parser.add_subparsers(title='subcommands',
                                           description='valid subcommands',
                                           help='init/start/migrate')

        parser_init = subparsers.add_parser('init')
        parser_init.set_defaults(which='init')
        parser_init.add_argument('--config_file', required=False,
                                 help='Config file may be passed as argument')

        parser_migrate = subparsers.add_parser('migrate')
        parser_migrate.set_defaults(which='migrate')

        parser_start = subparsers.add_parser('start')
        parser_start.set_defaults(which='start')

        args = vars(parser.parse_args())

        if args['which'] == 'init':
                if(args['config_file'] is None):
                    env = bootstrap('config/kinto.ini')
                else:
                    config_file = format(args['config_file'])
                    env = bootstrap(config_file)
        elif args['which'] == 'migrate':
                env = bootstrap('config/kinto.ini')
                cliquet.init_schema(env)
        elif args['which'] == 'start':
                pserve_argv = ['pserve', 'config/kinto.ini', '--reload']
                pserve.main(pserve_argv)

def quick_test(options):
    bootstrap(production=False)
    
    from runway.core.system.jobs.prune_logs import PruneLogsJob
    j = PruneLogsJob()
    j.perform_job(None)
    
    return ""

    def take_action(self, parsed_args):
        config = parsed_args.config
        bootstrap(config)

        create_blog(raw_input)

        import transaction
        transaction.commit()

def init_db(args):
    """Create database tables and elasticsearch indices."""
    # Force model creation using the MODEL_CREATE_ALL env var
    os.environ['MODEL_CREATE_ALL'] = 'True'

    # Start the application, triggering model creation
    paster.setup_logging(args.config_uri)
    paster.bootstrap(args.config_uri)

def main():
    if len(sys.argv) != 2:
        usage()

    config_uri = sys.argv[1]
    bootstrap(config_uri)

    Base.metadata.create_all()

def main(argv=sys.argv):  # pragma: no cover
    if len(argv) < 2:
        usage(argv)

    config_uri = argv[1]
    bootstrap(config_uri)
    setup_logging(config_uri)

    processor()

def bootstrap(args):
    """
    Bootstrap the application from the given arguments.

    Returns a bootstrapped request object.
    """
    paster.setup_logging(args.config_uri)
    request = Request.blank('/', base_url=args.base)
    paster.bootstrap(args.config_uri, request=request)
    return request

    def __init__(self, options):
        self.options = options
        self.imported = set()
        self.layers = []

        settings = {}
        with open(".build/config.yaml") as f:
            settings = yaml.load(f)

        self.languages = settings["available_locale_names"]

        # must be done only once we have loaded the project config
        from c2cgeoportal.models import DBSession, Interface, Theme, Role

        self.session = DBSession()

        self._ = {}
        self.metadata_service_url = \
            'http://shop.geoportail.lu/Portail/inspire/webservices/getMD.jsp'
        registry = bootstrap(self.options.app_config)['registry']
        request = bootstrap(self.options.app_config)['request']

        self.es_layer_index = get_index(request) + '_layers'
        self.tdirs = registry.queryUtility(ITranslationDirectories, default=[])
        self.tsf = TranslationStringFactory('geoportailv3-client')

        self.interfaces = self.session.query(Interface).filter(
            Interface.name.in_(options.interfaces)
        ).all()

        self.public_theme = {}
        self.public_group = {}
        for interface in self.interfaces:
            self.public_theme[interface.id] = []
            self.public_group[interface.id] = []

        for theme in self.session.query(Theme).filter_by(public=True).all():
            self._add_theme(theme)

        for role in self.session.query(Role).all():
            for theme in self.session.query(Theme).all():
                self._add_theme(theme, role)

        ensure_index(
            get_elasticsearch(request),
            self.es_layer_index,
            options.recreate_index
        )
        try:
            helpers.bulk(actions=self.layers,
                         client=get_elasticsearch(request),
                         raise_on_error=True)
        except (BulkIndexError, ConnectionTimeout) as e:
            statuslog("\n %s" % e)

    def take_action(self, parsed_args):
        from pyramid.paster import bootstrap
        from urakata.models import Scaffold, Session, Base
        bootstrap(parsed_args.config)

        # suppress logging
        Base.metadata.bind.echo = False

        header = [("name", "version", "repository", "utime")]
        row = [(s.name, s.version, s.repository.name, s.utime) for s in Session.query(Scaffold)]
        return header + [row]

def main():
    if len(sys.argv) != 2:
        usage()

    bootstrap(sys.argv[1])

    if shutil.which('convert') is None:
        print('Error: ImageMagick not found ("convert" is not in $PATH)')
        print('Try: sudo apt-get install imagemagick')
        sys.exit(2)

    create_logos()

def sql(options):
    bootstrap(production=False)
    
    results = cli_f.sql(*options.vals)
    
    for i, query in enumerate(results):
        print("")
        print(options.vals[i])
        if query.returns_rows:
            for row in query:
                print(row)
        print("")
    return ""

def main(argv=sys.argv):
    if len(argv) != 2:
        usage(argv)
    config_uri = argv[1]
    setup_logging(config_uri)
    settings = get_appsettings(config_uri)
    os.environ['PYJASPER_SERVLET_URL'] = settings['jasper_url'] 
    bootstrap(config_uri)
    engine = engine_from_config(settings, 'sqlalchemy.')
    other_engine = engine_from_config(settings, 'othersql.')
    Base.metadata.bind = engine
    OtherBase.metadata.bind = other_engine
    from ..models.esppt_models import (
        esNopModel,
        esRegModel,
        spptModel,
        )
    from ..views.es_reports import GenerateSppt
    DBSession.configure(bind=engine)
    q = DBSession.query(esNopModel, esRegModel).filter(
            esNopModel.es_reg_id == esRegModel.id)
    q = q.filter(esNopModel.email_sent == 0)
    for r_nop, r_reg in q:
        nop = get_nop(r_nop)
        q = spptModel.get_by_nop_thn(nop, r_nop.tahun)
        sppt = q.first()
        if not sppt:
            continue
        nilai = thousand(sppt.pbb_yg_harus_dibayar_sppt)
        g = GenerateSppt(nop, r_nop.tahun, r_reg.kode) 
        #USER_ID) updated menggunakan password dari user yang ada di reg.kode aagusti
        sppt_file = g.sppt_file
        e_filename = os.path.split(sppt_file)[-1]
        f = open(sppt_file)
        content = f.read()
        f.close()
        e_content = base64.encodestring(content)
        e_subject = EMAIL_SUBJECT.format(nop=nop, tahun=r_nop.tahun)
        e_body = EMAIL_BODY.format(nama_wp=sppt.nm_wp_sppt, nop=nop,
                    tahun=r_nop.tahun, nilai=nilai)
        files = [(e_filename, e_content)]
        print('To: {name} <{email}>'.format(name=sppt.nm_wp_sppt,
                email=r_reg.email))
        print('Subject: {s}'.format(s=e_subject))
        print('Body: {s}'.format(s=e_body))
        print('File: {s}'.format(s=e_filename))
        r_nop.email_sent = 1
        flush(r_nop)
        send(r_reg.email, sppt.nm_wp_sppt, e_subject, e_body, files,
                settings['email_pengirim'])
    transaction.commit()

def main(argv=sys.argv):
    if len(argv) < 2:
        usage(argv)
    config_uri = argv[1]
    bootstrap(config_uri)

    email = input('Input Email:')
    password = getpass.getpass('Input Password:')

    user = User(email=email)
    set_password(user, password)

    with transaction.manager:
        DBSession.add(user)

    def setup_app_from_commandline(self, argv):
        if argv is None:
            argv = sys.argv
        print argv
        if len(argv) < 2:
            print >> sys.stderr, 'No configuration file specified.'
            return argv
        if not self.conf:
            self.conf = argv.pop(1)
            argv.insert(1, 'worker')
        bootstrap(self.conf)

        self.app = default_app
        return argv

def main(argv=sys.argv):
    if len(argv) != 2:
        usage(argv)
    config_uri = argv[1]
    setup_logging(config_uri)
    settings = get_appsettings(config_uri)
    ziggurat_init(settings)
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    init_model()
    Base.metadata.create_all(engine) # Create non Ziggurat tables
    bootstrap(config_uri) # This make get_current_registry() works.
    insert_data(fixtures)
    create_default_permissions()
    transaction.commit()

    def command(self):
        from next.models import Base
        from shapely.wkb import loads
        from yaml import dump
        config_uri = self.args[0]
        env = bootstrap(config_uri)
        engine = engine_from_config(env['registry'].settings, 'sqlalchemy.')
        initialize_base(engine)

        tables = Base.metadata.sorted_tables
        assert self.args[1] is not None, 'You should provide a output file'
        yaml_file = open(self.args[1], 'w')
        fixtures = []

        for table in tables:
            for row in table.select().execute():
                c = {'table': table.name, 'fields': {}}
                columns = table.c.keys()
                # sanity check before we export the data
                assert len(columns) == len(row)
                for i in range(len(columns)):
                    column = table.c[columns[i]]
                    cell = row[i]
                    if str(column.type) in geom_types:
                        # we have to call str on the binary column first
                        c['fields'][column.name] = loads(str(cell)).wkt
                    else:
                        c['fields'][column.name] = cell

                fixtures.append(c)

        dump(fixtures, yaml_file)

def main():  # pragma: nocover
    env = bootstrap("development.ini")

    from c2cgeoportal.models import DBSession, TreeItem

    package = env["registry"].settings["package"]
    directory = "%s/locale/" % package
    destination = path.join(directory, "%s-db.pot" % package)

    w = codecs.open(destination, "wt", encoding="utf-8")
    w.write(
        u"""#, fuzzy
        msgid ""
        msgstr ""
        "MIME-Version: 1.0\\n"
        "Content-Type: text/plain; charset=utf-8\\n"
        "Content-Transfer-Encoding: 8bit\\n"

        """
    )

    treeitems = DBSession.query(TreeItem.item_type, TreeItem.id, TreeItem.name)
    for type, id, name in treeitems:
        w.write(
            u"""#: %(type)s.%(id)s
            msgid "%(name)s"
            msgstr ""

            """
            % {"type": type, "id": id, "name": name}
        )
    print("DB Pot file updated: %s" % destination)

def main(argv=sys.argv):
    if len(argv) < 3:
        usage(argv)
    config_uri = argv[1]
    json_path = argv[2]
    options = parse_vars(argv[3:])
    setup_logging(config_uri)
    # Configure the application, so we can access the registry.
    env = bootstrap(config_uri, options=options)
    # Generate a DBSession using the sessionmaker:
    DBSession = env['registry']['db_sessionmaker']()
    # The SQLAlchemy engine is accessible as the session's bind.
    engine = DBSession.bind
    Base.metadata.create_all(engine)
    json_data = json.load(open(json_path))
    with transaction.manager:
        for kitten_data in json_data:
            kitten = Kitten(source_url=kitten_data['source_url'],
                            credit=kitten_data['credit'])
            r = requests.get(kitten_data['download_url'])
            if r.headers['content-type'] == 'image/jpeg':
                kitten.file_extension = '.jpeg'
            elif r.headers['content-type'] == 'image/png':
                kitten.file_extension = '.png'
            kitten.file_data = r.content
            DBSession.add(kitten)
    # Not strictly necessary, as everything gets unwound when main returns anyway.
    # But it's a good habit to keep.
    env['closer']()