def main(argv=sys.argv):
    if len(argv) < 2:
        usage(argv)
    config_uri = argv[1]
    options = parse_vars(argv[2:])
    setup_logging(config_uri)
    settings = get_appsettings(config_uri, options=options)
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    Base.metadata.create_all(engine)
    with transaction.manager:
        model = Task(taskname='Learn 101 of telekinesis', status=False)
        DBSession.add(model)
        model = Task(taskname='Bend 20 forks', status=True)
        DBSession.add(model)
        model = Task(taskname='Become master in levitation', status=True)
        DBSession.add(model)
        model = Task(taskname='Go home flying', status=True)
        DBSession.add(model)

    with transaction.manager:
        admin = User(name=u'admin', password=u'admin')
        DBSession.add(admin)
        admin = User(name=u'demo', password=u'demo')
        DBSession.add(admin)

def main(argv=sys.argv):
    if len(argv) < 2:
        usage(argv)
    config_uri = argv[1]
    options = parse_vars(argv[2:])
    setup_logging(config_uri)
    settings = get_appsettings(config_uri, options=options)
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    Base.metadata.create_all(engine)
    #with transaction.manager:
    #    model = MyModel(name='one', value=1)
    #    DBSession.add(model)

    with transaction.manager:
        with open('agencies.csv','r') as f:
            agencies = f.read().split('\n')

        for agency in agencies:
            if agency.strip() != '':
                # agencyid, shortname, longname, type, description, websiteurl
                parts = agency.split('\t')
                agency_type = AgencyTypes.get_from_code(DBSession, parts[3])
                a = Agencies(
                    agency_code = parts[1],
                    agency_name = parts[2],
                    type_id = agency_type.id,
                    description = parts[4],
                    website = parts[5],
                )
                DBSession.add(a)
                transaction.commit()

    def run(self):
        if len(self.args) < 2:
            self.out('Command requires a config file arg and a url arg')
            return 2
        config_uri = self.args[0]
        url = self.args[1]

        if not url.startswith('/'):
            url = '/%s' % url
        request = Request.blank(url)
        env = self.bootstrap[0](config_uri, options=parse_vars(self.args[2:]),
                                request=request)
        view = self._find_view(request)
        self.out('')
        self.out("URL = %s" % url)
        self.out('')
        if view is not None:
            self.out("    context: %s" % view.__request_attrs__['context'])
            self.out("    view name: %s" % view.__request_attrs__['view_name'])
        if IMultiView.providedBy(view):
            for dummy, view_wrapper, dummy in view.views:
                self.output_view_info(view_wrapper)
                if IMultiView.providedBy(view_wrapper):
                    for dummy, mv_view_wrapper, dummy in view_wrapper.views:
                        self.output_view_info(mv_view_wrapper, level=2)
        else:
            if view is not None:
                self.output_view_info(view)
            else:
                self.out("    Not found.")
        self.out('')
        env['closer']()
        return 0

    def get_options(self):
        if len(self.args) > 1 and self.args[1] in self.possible_subcommands:
            restvars = self.args[2:]
        else:
            restvars = self.args[1:]

        return parse_vars(restvars)

def main(argv=sys.argv):
    if len(argv) < 2:
        usage(argv)
    config_uri = argv[1]
    options = parse_vars(argv[2:])
    setup_logging(config_uri)
    settings = get_appsettings(config_uri, options=options)
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    Base.metadata.drop_all(engine)
    Base.metadata.create_all(engine)
    with transaction.manager:
		
		model2 = Genre(id = 0,name='HipHop', info='Nigger ma fucker',year_of_found = 1990)
		DBSession.add(model2)
		
		model = Genre(id = 1,name='GlitchHop', info='Nu vaaassheee',year_of_found = 2014, parent_genre = model2)
		DBSession.add(model)

                model3 = Genre(id = 2,name='Grime', info='Zhostkiy rap',year_of_found = 2006, parent_genre = model2)
		DBSession.add(model3)

                model4 = Genre(id = 3,name='Dark Grime', info='Tyomniy Zhostkiy rap',year_of_found = 2009, parent_genre = model3)
		DBSession.add(model4)
		
		music1 = Music(author = 'Simplex_Method', title = 'Of Literal Data', year = 2015,genre =  model3)
		DBSession.add(music1)

def main(argv=sys.argv):
    if len(argv) < 2:
        usage(argv)
    config_uri = argv[1]
    options = parse_vars(argv[2:])
    setup_logging(config_uri)
    settings = get_appsettings(config_uri, options=options)
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    Base.metadata.create_all(engine)

    application_pdf_doc_type = DocumentTypes.add(
        name="Adobe PDF",
        description="Adobe PDF file",
        mime_type="application/pdf",
    )

    system_owner = Users.add(
        first="SYSTEM",
        last="USERS",
        email="[email protected]",
        password="password",
    )

    default_scraper = Scrapers.add(
        name="Default Scraper",
        description="CivicDocs.IO loads with a single, defualt scraper.",
        owner_id=system_owner.id,
    )

    print("DEFAULT SCRAPER ID:\r\n{0}\r\n".format(default_scraper.id))

def main(argv=sys.argv):
    if len(argv) < 2:
        usage(argv)
    config_uri = argv[1]
    options = parse_vars(argv[2:])
    setup_logging(config_uri)
    settings = get_appsettings(config_uri, options=options)
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    Base.metadata.drop_all(engine)
    Base.metadata.create_all(engine)
    with transaction.manager:
        user = User(username='admin', password='apass', email=settings.get('admin_mail'), activated=True,
                    groups='admin')
        DBSession.add(user)
        DBSession.flush()
        for k, v in Settings.settings.iteritems():
            if type(v) == dict:
                DBSession.add(Settings(key=unicode(k), value=unicode(v['value'])))
            else:
                if isinstance(v, basestring) and v.startswith('app_config.'):
                    v = settings.get(v[len('app_config.'):])
                DBSession.add(Settings(key=unicode(k), value=unicode(v)))

        DBSession.flush()

def main(argv=sys.argv):
    if len(argv) < 2:
        usage(argv)
    config_uri = argv[1]
    options = parse_vars(argv[2:])
    setup_logging(config_uri)
    settings = get_appsettings(config_uri, options=options)
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    Base.metadata.create_all(engine)
    with transaction.manager:
        #model = MyModel(name='one', value=1)
        #DBSession.add(model)

        megan_user = Users.create_user(
            session = DBSession,
            username = 'megan',
            password = 'password',
            name = 'Megan',
        )
        DBSession.add(megan_user)
        
        tim_user = Users.create_user(
            session = DBSession,
            username = 'tim',
            password = 'password',
            name = 'Tim',
        )
        DBSession.add(tim_user)

        transaction.commit()

def main(argv=sys.argv):
    if len(argv) < 2:
        usage(argv)
    config_uri = argv[1]
    options = parse_vars(argv[2:])
    setup_logging(config_uri)
    settings = get_appsettings(config_uri, options=options)

    engine = get_engine(settings)
    dbmaker = get_dbmaker(engine)

    dbsession = get_session(transaction.manager, dbmaker)

    Base.metadata.create_all(engine)

    acl1 = [(Allow, Everyone, "view")]
    acl2 = [(Allow, "editor", "view")]
    acl3 = [(Allow, "admin", "view")]

    with transaction.manager:
        root = RootFolder(name="", title="sqltraversal Demo")
        dbsession.add(root)
        f1 = root["f1"] = Folder(
            title="Folder 1"
            # no persistent acl
        )
        root["f2"] = Folder(title="Folder 2 All", acl=acl1)
        root["f3"] = Folder(title="Folder 3 Editor", acl=acl2)
        root["f4"] = Folder(title="Folder 4 Admin", acl=acl3)
        root["f5"] = Folder(title="Folder 5 Editor", acl=acl2)
        root["f6"] = Folder(title="Folder 6 Admin", acl=acl3)
        f1["d1"] = Document(title="Document 1")

def main(argv=sys.argv):
    if len(argv) < 2:
        usage(argv)
    config_uri = argv[1]
    options = parse_vars(argv[2:])
    setup_logging(config_uri)
    settings = get_appsettings(config_uri, options=options)
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    Base.metadata.create_all(engine)
    with transaction.manager:
        #model = MyModel(name='one', value=1)
        #DBSession.add(model)

        perm_item_manage = Permission()
        perm_item_manage.name = 'item'
        DBSession.add(perm_item_manage)

        perm_user_manage = Permission()
        perm_user_manage.name = 'user'
        DBSession.add(perm_user_manage)

        perm_order_manage = Permission()
        perm_order_manage.name = 'order'
        DBSession.add(perm_order_manage)

        gadmin = Group()
        gadmin.name = 'Administrators'
        gadmin.permissions.append(perm_item_manage)
        gadmin.permissions.append(perm_order_manage)
        gadmin.permissions.append(perm_user_manage)
        DBSession.add(gadmin)

        admin = User()
        admin.name = 'admin'
        admin.password = 'admin'
        admin.email = '[email protected]'
        admin.group = gadmin
        DBSession.add(admin)

        cat_food = Category()
        cat_food.name = 'Food'
        DBSession.add(cat_food)

        cat_fruit = Category()
        cat_fruit.name = 'Fruit'
        cat_fruit.parent = cat_food
        DBSession.add(cat_fruit)

        cat_vegetable = Category()
        cat_vegetable.name = 'Vegetable'
        cat_vegetable.parent = cat_food
        DBSession.add(cat_vegetable)

        iapple = Item()
        iapple.name = 'Apple'
        iapple.description = '<h2>This is a <span style="color:red;">red</span> apple</h2>'
        iapple.price = 1.3
        iapple.category = cat_fruit
        DBSession.add(iapple)

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

    # configure connections for Postgres, ElasticSearch and Redis
    settings = get_appsettings(config_uri, options=options)
    engine = engine_from_config(settings, 'sqlalchemy.')
    Session = sessionmaker()  # noqa
    Session.configure(bind=engine)
    configure_es_from_config(settings)
    queue_config = get_queue_config(settings)
    batch_size = int(settings.get('elasticsearch.batch_size.syncer', 1000))

    with queue_config.connection:
        try:
            worker = SyncWorker(
                queue_config.connection, queue_config.queue, batch_size,
                session_factory=Session)
            log.info('Syncer started, running initial sync')
            worker.sync()
            log.info('Waiting on messages')
            worker.run()
        except KeyboardInterrupt:
            log.info('Syncer stopped')

def main(argv=sys.argv):
    if len(argv) < 2:
        usage(argv)
    config_uri = argv[1]
    options = parse_vars(argv[2:])
    setup_logging(config_uri)
    settings = get_appsettings(config_uri, options=options)
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    Base.metadata.create_all(engine)

	#Generate fake statistics for 1 year
    DAYS = 365 * 1

    #Init database with example list of cities
    with transaction.manager:
        for c in CITIES:
            city = City(name=c, owm_id=CITIES[c])
            DBSession.add(city)
            DBSession.flush()
            print("Added city: " + city.name)            
            prev_y = datetime.datetime.now() - datetime.timedelta(DAYS)
            
            for d in (prev_y + datetime.timedelta(n) for n in range(DAYS)):
                is_clear = bool(random.getrandbits(1))
                wr = WeatherRecord(city=city.id, date=d, is_clear=is_clear)
                DBSession.add(wr)
                print("Added weather record: " + str(wr.date) + " " + str(wr.is_clear))                
            DBSession.flush()

def main(argv=sys.argv):
    if len(argv) < 2:
        usage(argv)
    config_uri = argv[1]
    options = parse_vars(argv[2:])
    setup_logging(config_uri)
    settings = get_appsettings(config_uri, options=options)

    engine = get_engine(settings)
    Base.metadata.create_all(engine)

    session_factory = get_session_factory(engine)

    with transaction.manager:
        dbsession = get_tm_session(session_factory, transaction.manager)

        submitter = Submitter(name='tester')
        dbsession.add(submitter)
        transaction.commit()
        sub_id = dbsession.query(Submitter.id). \
                 filter(Submitter.name == 'tester').scalar()
        post = Post(title="job title",
                    company="the testing company",
                    post_date="13-Apr-2016Z201530",
                    description="this is a really short description",
                    submitter=sub_id)
        dbsession.add(post)

def main(argv=sys.argv):
    from ..src import User, Address
    if len(argv) < 2:
        usage(argv)
    config_uri = argv[1]
    options = parse_vars(argv[2:])
    setup_logging(config_uri)
    settings = get_appsettings(config_uri, options=options)
    engine = engine_from_config(settings, 'sqlalchemy.')
    Session.configure(bind=engine)
    BaseModel.metadata.create_all(engine)
    with transaction.manager:
        brendan = User(name='Brendan', age=18)
        Session.add(brendan)
        Session.flush()

        brendan_address = Address(city='Paris', owner_id=brendan.id)
        Session.add(brendan_address)
        Session.flush()

        john = User(name='John', age=19, best_friend_id=brendan.id)
        Session.add(john)
        Session.flush()

        antoine = User(name='Antoine', age=20)
        Session.add(antoine)
        Session.flush()

def main(argv=sys.argv):
    if len(argv) < 2:
        usage(argv)
    config_uri = argv[1]
    options = parse_vars(argv[2:])
    setup_logging(config_uri)
    settings = get_appsettings(config_uri, options=options)
    connect_string = settings['sqlalchemy.url']\
        .replace('DBUser', os.environ['DBUSER'])\
        .replace('DBPassword', os.environ['DBPASSWORD'])
    settings['sqlalchemy.url'] = connect_string
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    Base.metadata.create_all(engine)
    with transaction.manager:
        store_data = json.loads(open('emporium/scripts/store_data.json').
                                read())

        suppliers = {}
        for item in store_data['suppliers']:
            supplier = Supplier(name=item['name'], tax_id=item['tax_id'])
            suppliers[supplier.name] = supplier
            DBSession.add(supplier)

        for item in store_data['bargains']:
            bargain = Bargain(
                sku=item['sku'],
                price=item['price'],
                supplier=suppliers[item['supplier_name']]
            )
            bargain.info = item['info']
            DBSession.add(bargain)

def main(argv=sys.argv):
    if len(argv) < 2:
        usage(argv)
    config_uri = argv[1]
    options = parse_vars(argv[2:])
    setup_logging(config_uri)
    settings = get_appsettings(config_uri, options=options)
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    Base.metadata.create_all(engine)
    #with transaction.manager:
    #    model = MyModel(name='one', value=1)
    #    DBSession.add(model)

    c = Customers.add(
        session = DBSession,
        name = "GE",
        description = "General Electric Corp."
    )

    a = Accounts.add(
        session = DBSession, 
        customer_id = c.id,
        name = 'GE Location X',
        description = 'The GE Plant at Location X',
    )

def main(argv=sys.argv):
    if len(argv) < 2:
        usage(argv)
    config_uri = argv[1]
    options = parse_vars(argv[2:])
    setup_logging(config_uri)
    settings = get_appsettings(config_uri, options=options)
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    Base.metadata.create_all(engine)

    with transaction.manager:
        user = User(email='[email protected]', password='test', admin=True)
        DBSession.add(user)
        site = Site(name='asd', key='80d621df066348e5938a469730ae0cab')
        DBSession.add(site)
        site.api_keys.append(SiteAPIKey(key='GIKfxIcIHPbM0uX9PrQ1To29Pb2on0pa'))
        site.users.append(user)

        aspect_ratio_1_1 = SiteAspectRatio(width=1, height=1)
        aspect_ratio_3_1 = SiteAspectRatio(width=3, height=1)
        site.aspect_ratios.append(aspect_ratio_1_1)
        site.aspect_ratios.append(aspect_ratio_3_1)

    from alembic.config import Config
    from alembic import command
    alembic_cfg = Config("alembic.ini")
    command.stamp(alembic_cfg, "head")

def main(argv=sys.argv):
    if len(argv) < 2:
        usage(argv)
    config_uri = argv[1]
    options = parse_vars(argv[2:])
    setup_logging(config_uri)
    settings = get_appsettings(config_uri, options=options)
    engine = engine_from_config(settings, 'sqlalchemy.')
    DBSession.configure(bind=engine)
    Base.metadata.create_all(engine)
    
    # initial encryption passphrase set to ''
    salt = os.urandom(32)

    password = bytes(input("If you would like to set a password, please enter it now. Otherwise, just press enter. > ").encode())
    
    # initial password is the empty string
    enc_key = gen_key_from_salt_and_password(salt, password)
    f = Fernet(enc_key)

    secret_exponent_bytes = os.urandom(32)
    secret_exponent = convert_se_bytes(secret_exponent_bytes)
    address = Key(secret_exponent=secret_exponent, netcode=NET_CODE['bitcoin']).address(use_uncompressed=USE_COMPRESSED)

    with transaction.manager:
        model = KeyStore(name=PRIMARY, encrypted=f.encrypt(secret_exponent_bytes),
                         salt=salt, address=address)
        DBSession.add(model)

    def run(self, argv):
        if len(argv) < 3:
            self.usage(argv)
        config_uri = argv[1]
        fromDate = argv[2]
        options = parse_vars(argv[3:])
        setup_logging(config_uri)
        settings = get_appsettings(config_uri, options=options)
        engine = engine_from_config(settings, 'sqlalchemy.')

        DBSession.configure(bind=engine)
        Base.metadata.create_all(engine)
        with transaction.manager:
            url = 'https://servicesenligne2.ville.montreal.qc.ca/api/infoneige/InfoneigeWebService?wsdl'
            client = Client(url)
            planification_request = client.factory.create('getPlanificationsForDate')
            planification_request.fromDate = fromDate
            planification_request.tokenString =  'ug33-b81ab488-c335-4021-9c52-26d6b8523301-e7aa002b-0d9d-4b5c-81ef-b012979cdafb-dab06588-1962-4b16-9942-a18054094f60-a4186179-d555-4fed-b35f-ec0c74da97a3-aa3b3766-4d26-42f0-888a-a6569a1dd745'
            response = client.service.GetPlanificationsForDate(planification_request)
            if response['responseStatus'] == 0:
                log.info('%s plannings returned', response['planifications']['count'])
                cartodb_client = CartoDBOAuth(settings['cartodb.key'], settings['cartodb.secret'], settings['cartodb.user'], settings['cartodb.password'], settings['cartodb.domain'])

                for result in response['planifications']['planification']:
                    '''
                    street_side_status = StreetSideHistory(
                        municipality_id = result['munid'],
                        street_side_id = result['coteRueId'],
                        state = result['etatDeneig'],
                        observed_on = result['dateMaj'],
                        )
                    DBSession.merge(street_side_status)
                    '''
                    if any(val in result for val in ['dateDebutPlanif', 'dateFinPlanif', 'dateDebutReplanif', 'dateFinReplanif']):
                        try:
                            result['dateDebutReplanif']
                        except AttributeError:
                            result['dateDebutReplanif'] = None
                        try:
                            result['dateFinReplanif']
                        except AttributeError:
                            result['dateFinReplanif'] = None
                        '''
                        print result
                        planning = Planning(
                            municipality_id = result['munid'],
                            street_side_id = result['coteRueId'],
                            planned_start_date = result['dateDebutPlanif'],
                            planned_end_date = result['dateFinPlanif'],
                            replanned_start_date = result['dateDebutReplanif'],
                            replanned_end_date = result['dateFinReplanif'],
                            modified_on = result['dateMaj'],
                            )
                        DBSession.merge(planning)
                        '''
                    #transaction.manager.commit()
                    cartodb_client.sql('UPDATE cote SET etat = %(etat)s WHERE cote_rue_id = %(cote_rue_id)d' %
                        {"etat": result['etatDeneig'], "cote_rue_id": result['coteRueId']})
            else:
                log.info('Status %s: %s', response['responseStatus'], response['responseDesc'])

def main(argv=sys.argv):
    if len(argv) < 2:
        usage(argv)
    config_uri = argv[1]
    options = parse_vars(argv[2:])
    setup_logging(config_uri)
    settings = get_appsettings(config_uri, options=options)

    engine = get_engine(settings)
    Base.metadata.create_all(engine)

    session_factory = get_session_factory(engine)

    with transaction.manager:
        dbsession = get_tm_session(session_factory, transaction.manager)

        editor = User(name='editor', role='editor')
        editor.set_password('editor')
        dbsession.add(editor)

        basic = User(name='basic', role='basic')
        basic.set_password('basic')
        dbsession.add(basic)

        page = Page(
            name='FrontPage',
            creator=editor,
            data='This is the front page',
        )
        dbsession.add(page)