def main(self, *args, **kwargs): obj = kwargs.get('obj') if obj is None: obj = FrascoScriptInfo(create_app=self.create_app) kwargs['obj'] = obj kwargs.setdefault('auto_envvar_prefix', 'FRASCO') return AppGroup.main(self, *args, **kwargs)
from flask.cli import AppGroup from .users import seed_users, undo_users from .businesses import seed_businesses, undo_businesses from .items import seed_items, undo_items from .charities import seed_charities, undo_charities # Creates a seed group to hold our commands # So we can type `flask seed --help` seed_commands = AppGroup('seed') # Creates the `flask seed all` command @seed_commands.command('all') def seed(): seed_users() seed_businesses() seed_items() seed_charities() # Add other seed functions here # Creates the `flask seed undo` command @seed_commands.command('undo') def undo(): undo_users() undo_businesses() undo_items() undo_charities() # Add other undo functions here
from flask import current_app from flask.cli import AppGroup, with_appcontext from linotp.app import allocate_security_module, set_config from linotp.lib.support import ( InvalidLicenseException, getSupportLicenseInfo, isSupportLicenseValid, parseSupportLicense, setSupportLicense, ) from linotp.model import db support_cmds = AppGroup( "support", help="Administrative commands to set and query the linotp support.", ) def _setup_security_context(): """Arrange things such that we can read or write part of the data in a demo license, which is stored encrypted. We need to re-invoke `allocate_security_module()` here, in spite of the fact that this has already been done in `create_app()`, because it uses `request_context` to hold the result. Since `request_context` is part of the `flask.g` application context, and the application context here is different from the one used while finding an HSM connection in `create_app()`, that result is gone now and we need to call the function again. """
# XXX: Do not import any other indico modules here! # If any import from this module triggers an exception the dev server # will die while an exception only happening during app creation will # be handled gracefully. from indico.cli.util import IndicoFlaskGroup, LazyGroup click.disable_unicode_literals_warning = True __all__ = ('cli_command', 'cli_group') # We never use the group but expose cli_command and cli_group for # plugins to have access to the flask-enhanced command and group # decorators that use the app context by default _cli = AppGroup() cli_command = _cli.command cli_group = _cli.group del _cli def _get_indico_version(ctx, param, value): if not value or ctx.resilient_parsing: return import indico message = 'Indico v{}'.format(indico.__version__) click.echo(message, ctx.color) ctx.exit() @click.group(cls=IndicoFlaskGroup)
import click from flask.cli import AppGroup from app import app import models from app import db db_cli = AppGroup('db') @db_cli.command('drop') def drop(): db.drop_all() @db_cli.command('create') def create(default_data=True, sample_data=False): "Creates database tables from sqlalchemy models" db.create_all() @db_cli.command('recreate') def recreate(default_data=True, sample_data=False): "Recreates database tables (same as issuing 'drop' and then 'create')" db.drop_all() db.create_all() app.cli.add_command(db_cli)
import click from flask.cli import AppGroup from friday.models import User from friday.utils import get_random_string user = AppGroup("user") @user.command("new") @click.argument("email") @click.option("--password") def make_user(email, password): """Create new user""" if not password: password = get_random_string() click.echo("New password: {}".format(password)) User.create(email=email, password=password) @user.command("change_password") @click.argument("user_id") @click.option("--password") def change_password(user_id, password): """Change user password""" usr = User.get(user_id) if not usr: click.echo("Not found") return if not password: password = get_random_string() click.echo("New password: {}".format(password))
from .models import User, db import click from flask.cli import AppGroup admin_cli = AppGroup("roles") @admin_cli.command("add") @click.option("--email") @click.argument("role") def add_role(role, email): user = User.by_email(email) if not user: click.echo("The specified user does not exist.") click.exit(1) try: user.add_role(role) db.session.commit() except ValueError: click.echo("The specified role is not defined.") click.exit(1) click.echo("User {} now has role {}.".format(email, role))
import os from flask import Flask from flask.cli import with_appcontext, AppGroup from flask_login import LoginManager, current_user from flask_sqlalchemy import SQLAlchemy from flask_migrate import Migrate, MigrateCommand import click import json import logging import traceback db = SQLAlchemy() login_manager = LoginManager() stock_cli = AppGroup("stock") def create_app(test_config=None): # create and configure the app app = Flask(__name__, instance_relative_config=True) try: import flaskr.model if test_config is None: # load the instance config, if it exists, when not testing config_file = os.environ['PORTFOLIO_CONFIG_FILE'] app.config.from_pyfile(config_file, silent=True) else: # load the test config if passed in app.config.from_mapping(test_config)
from click import argument from flask.cli import AppGroup from redash import models manager = AppGroup(help="Organization management commands.") @manager.command() @argument("domains") def set_google_apps_domains(domains): """ Sets the allowable domains to the comma separated list DOMAINS. """ organization = models.Organization.query.first() k = models.Organization.SETTING_GOOGLE_APPS_DOMAINS organization.settings[k] = domains.split(",") models.db.session.add(organization) models.db.session.commit() print("Updated list of google allowed domains to: {}".format( organization.google_apps_domains)) @manager.command() def show_google_apps_domains(): organization = models.Organization.query.first() print("Current list of Google Apps domains: {}".format(", ".join( organization.google_apps_domains))) @manager.command()
from sys import exit from sqlalchemy.orm.exc import NoResultFound from flask.cli import AppGroup from click import argument, option from redash import models manager = AppGroup(help="Groups management commands.") @manager.command() @argument('name') @option('--org', 'organization', default='default', help="The organization the user belongs to (leave blank for " "'default').") @option('--permissions', default=None, help="Comma separated list of permissions ('create_dashboard'," " 'create_query', 'edit_dashboard', 'edit_query', " "'view_query', 'view_source', 'execute_query', 'list_users'," " 'schedule_query', 'list_dashboards', 'list_alerts'," " 'list_data_sources') (leave blank for default).") def create(name, permissions=None, organization='default'): print "Creating group (%s)..." % (name) org = models.Organization.get_by_slug(organization) permissions = extract_permissions_string(permissions)
import click from flask.cli import AppGroup from flask.cli import with_appcontext from depc.controllers import NotFoundError from depc.controllers.users import UserController user_cli = AppGroup("user", help="Manage users.") @user_cli.command("create") @with_appcontext @click.argument("name", default=None, required=True, type=str) @click.option("--admin", default=False, required=False, type=bool, is_flag=True) def create_user(name, admin): """Create a new user.""" is_admin = bool(admin) try: user = UserController._get(filters={"User": {"name": name}}) click.echo("User {name} already exists with id: {id}".format( name=name, id=user.id)) except NotFoundError: click.confirm( "User {name} will be created with admin = {admin}".format( name=name, admin=is_admin), abort=True, )
from __future__ import absolute_import import socket import sys import datetime from click import argument from flask.cli import AppGroup from rq import Connection, Worker from sqlalchemy.orm import configure_mappers from redash import rq_redis_connection from redash.schedule import rq_scheduler, schedule_periodic_jobs, periodic_job_definitions manager = AppGroup(help="RQ management commands.") @manager.command() def scheduler(): jobs = periodic_job_definitions() schedule_periodic_jobs(jobs) rq_scheduler.run() @manager.command() @argument('queues', nargs=-1) def worker(queues): # Configure any SQLAlchemy mappers loaded until now so that the mapping configuration # will already be available to the forked work horses and they won't need # to spend valuable time re-doing that on every fork. configure_mappers()
import os from homework.models import User, Image, Metadata from flask import current_app from homework.database import db from flask.cli import AppGroup import click core_cli = AppGroup("core") @core_cli.command("init") def app_init(): if not os.path.exists(current_app.instance_path): os.makedirs(current_app.instance_path) print("[x] Created instance folder") db.create_all() print("[x] Created database") print("App is ready to launch. Run `flask run` to start a production server.") @core_cli.command("nuke") def app_init(): db.drop_all() print("[x] Destroyed database") db.create_all() print("[x] Created database") if not os.path.exists(current_app.instance_path): os.makedirs(current_app.instance_path) print("[x] Created instance folder") print("App is ready to launch. Run `flask run` to start a production server.")
import click from flask.cli import AppGroup user_cli = AppGroup('user') @user_cli.command('create') @click.option('--level', type=click.Choice(['0', '1', '2', '3']), required=True, help='user permission level') @click.argument('username') @click.argument('password') @click.argument('person_id') def create(level, username, password, person_id): from ..models import UserLogins, Users from ..models import db new_user = Users(person_id=person_id) db.session.add(new_user) db.session.flush() new_user_login = UserLogins(user_id=new_user.id, username=username, level=level) new_user_login.set_password(password) db.session.add(new_user_login) db.session.commit()
import time import click import redis from flask import current_app from flask.cli import AppGroup from pychunkedgraph.backend.chunkedgraph import ChunkedGraph from pychunkedgraph.meshing import meshgen import cloudvolume import numpy as np from datetime import datetime ingest_cli = AppGroup('mesh') num_messages = 0 messages = [] cg = ChunkedGraph('fly_v31') def handlerino_write_to_cloud(*args, **kwargs): global num_messages num_messages = num_messages + 1 print(num_messages, args[0]['data']) messages.append(args[0]['data']) with open('output.txt', 'a') as f: f.write(str(args[0]['data']) + '\n') if num_messages == 1000: print('DONE') cv_path = cg._cv_path with cloudvolume.Storage(cv_path) as storage: storage.put_file(
def get_command(self, ctx, name): rv = AppGroup.get_command(self, ctx, name) if rv is not None: return rv return self._get_indico_plugin_commands(ctx).get(name)
#!/usr/bin/env python3 from webserver.models import User from webserver import app, db, views from flask.cli import AppGroup cli_group_db = AppGroup('db') @cli_group_db.command('init') def init_db(): db.create_all() # TODO: configure default user here db.session.add(User(username="******", password="******")) db.session.add(User(username="******", password="******")) db.session.add(User(username="******", password="******")) db.session.commit() @cli_group_db.command('drop') def drop_db(): db.drop_all() app.cli.add_command(cli_group_db) if __name__ == "__main__": app.run(host='0.0.0.0', port=80)
from datetime import datetime from logging import getLogger import click from flask.cli import AppGroup from rental_app.controllers.cars import CarsController from rental_app.controllers.rents import RentsController car_cli = AppGroup("car", help="all cli related to car") rent_cli = AppGroup("rent", help="all cli related to rent") _log = getLogger(__name__) @car_cli.command("create") @click.argument("registration_number") @click.argument("color") def create_car(registration_number: str, color: str): if registration_number == "" or color == "": raise NotImplementedError result = CarsController.create( data=dict(registration_number=registration_number, color=color) ) print(result) @car_cli.command("search") @click.argument("registration_number") def search_car(registration_number: str): result = CarsController.get(keyword=registration_number) print(result)
import time import requests from datetime import datetime import redis from redis import Redis from flask import current_app from flask.cli import AppGroup from rq_scheduler import Scheduler from towerdashboard import db cmds = AppGroup("dashboard") def wait_for(func, retries=60): count = 0 while True: res = func() if res: return True if count < retries: count += 1 time.sleep(1) else: break return False
def app_group(*args, **kwargs): grp = AppGroup(*args, **kwargs) _commands.append(grp) return grp
from sqlalchemy.orm.exc import NoResultFound from flask.cli import AppGroup from redap.models.apikey import APIKey from redap.exceptions import InvalidConfiguration try: from redap.api import create_app app = create_app() except InvalidConfiguration as error: sys.stderr.write( "Configuration file '{0}' failed validation: \n{1}".format( error.file, error.cause)) sys.exit(4) key_cli = AppGroup('auth', help='Manage API keys') def generate_apikey_table(api_keys): table = list() table.append('\nAPI key{0}Description'.format(' ' * 58)) table.append('{0} {1}'.format('=' * 64, '=' * 16)) for api_key in api_keys: enabled = '' if api_key.enabled else '*' table.append('{0}{1} {2}'.format(api_key.key, enabled, api_key.description)) return '\n'.join(table)
import click from flask.cli import AppGroup from peewee import fn from app.models import User, UserMetadata admin = AppGroup("admin", help="Manages admin users") @admin.command(help="Grants admin privileges to an user") @click.argument("username") def add(username): try: user = User.get(fn.Lower(User.name) == username.lower()) except User.DoesNotExist: print("Error: User does not exist") return UserMetadata.create(uid=user.uid, key="admin", value="1") print("Done.") @admin.command(help="Removes admin privileges for an user") @click.argument("username") def remove(username): try: user = User.get(fn.Lower(User.name) == username.lower()) except User.DoesNotExist: return print("Error: User does not exist.") try: umeta = UserMetadata.get( (UserMetadata.uid == user.uid) & (UserMetadata.key == "admin")
from flask.cli import AppGroup from .modelsMSSQL import db as msDb from .modelsMySQL import db as myDb apps = AppGroup('apps') @apps.command('create-tables') def createTables(): msDb.create_all() myDb.create_all() def init_app(app): app.cli.add_command(apps)
import click from flask import Flask from flask.cli import AppGroup, with_appcontext from ..data.registry import get_registry, process_registry cli = AppGroup('registry') @cli.command('update') @click.option('--skip-cache/--use-cache', default=True, help='whether to use a cached version if available') @with_appcontext def cli_update_register(skip_cache): reg = get_registry(skip_cache=skip_cache) processed = process_registry(reg) click.echo("Registry loaded{}. Contains {:,.0f} files from {:,.0f} publishers".format( "" if skip_cache else " (from cache)", len(reg), len(processed) ))
import click import app.models as models from flask.cli import AppGroup from werkzeug.security import generate_password_hash from config.database import db dbase = AppGroup('dbase') @dbase.command() def create_all_tabs(): """Creating tables in database by all models in app""" ArModels = models.all_models() print(ArModels) db.database.create_tables(ArModels) @dbase.command() @click.argument('name') def create_table(name): """Create table in database""" mod = models.one_model(name) if mod is not None: mod.create_table() else: print('таблица не существует') @dbase.command() @click.argument('login') def create_admin(login):
# coding=utf-8 from os import makedirs from os import path from flask.cli import AppGroup from flask_sqlalchemy import SQLAlchemy db = SQLAlchemy() db_cli = AppGroup('database') def init_app(app): """Initializes the application database (SQL). :param app: The Flask application object. """ db.init_app(app) app.cli.add_command(db_cli) try: # Ensure the database folder exists database_folder = path.join(app.instance_path, app.config['DATABASE_FOLDER']) if not path.isdir(database_folder): makedirs(database_folder) raise Exception( f'Directory not found, so just created: {database_folder}') except OSError as ex: app.logger.error(str(ex)) except Exception as ex:
''' import click from flask.cli import AppGroup import csv import json import os from selenium import webdriver from selenium.webdriver.firefox.options import Options from axe_selenium_python import Axe from flask import current_app as app axe_path = app.config['AXE_PATH'] axe_cli = AppGroup('axe') def test_page(page): options = Options() options.headless = True driver = webdriver.Firefox(options=options) driver.get(page[1]) axe = Axe(driver) # Inject axe-core javascript into page. axe.inject() # Run axe accessibility checks. results = axe.run()
import click from flask.cli import AppGroup from thefort.database import db from flask import current_app import os from datetime import datetime from thefort.models import User, Role core_cli = AppGroup("core") user_cli = AppGroup("user") db_cli = AppGroup("db") @db_cli.command("nuke") def nuke(): db.drop_all() @core_cli.command("init") def app_init(): # create instance directory if it doesn't already exist: if not os.path.exists(current_app.instance_path): os.makedirs(current_app.instance_path) print("[x] Created instance folder") db.create_all() print("[x] Created database") roles = ["admin", "user"] for role in roles: r = Role(role) db.session.add(r) db.session.commit()
SESSION_COOKIE_SECURE = True DATABASE_URI = "sqlite:///" + os.path.join(basedir, "linotp.sqlite") configs = { "development": DevelopmentConfig, "testing": TestingConfig, "production": ProductionConfig, "default": DevelopmentConfig, } # ---------------------------------------------------------------------- # CLI commands # ---------------------------------------------------------------------- config_cmds = AppGroup("config", help="Show LinOTP configuration") @config_cmds.command("show", help="Output current configuration settings.") @click.option( "--modified", "-m", is_flag=True, help="Show only items whose values differ from their defaults.", ) @click.option( "--values", "-V", is_flag=True, help="Show only values of items, not their names.", )
from sys import exit import click from flask.cli import AppGroup from six import text_type from sqlalchemy.orm.exc import NoResultFound from redash import models from redash.query_runner import ( get_configuration_schema_for_query_runner_type, query_runners) from redash.utils import json_loads from redash.utils.configuration import ConfigurationContainer manager = AppGroup(help="Data sources management commands.") @manager.command(name='list') @click.option('--org', 'organization', default=None, help="The organization the user belongs to (leave blank for " "all organizations).") def list_command(organization=None): """List currently configured data sources.""" if organization: org = models.Organization.get_by_slug(organization) data_sources = models.DataSource.query.filter( models.DataSource.org == org) else: data_sources = models.DataSource.query for i, ds in enumerate(data_sources.order_by(models.DataSource.name)):
from flask.cli import AppGroup, current_app import click import subprocess from shlex import quote as shlex_quote celery_cli = AppGroup("celery_cmd", help="Celery Cli Commands") @celery_cli.command() def init_celery(): cmd = shlex_quote("celery -A app.tasks.tasks worker -l INFO") subprocess.call(cmd) return None @celery_cli.command() def get_celery_tasks(): celery = current_app.celery_worker click.echo(celery.conf) return None @celery_cli.command() def cancel_all_scheduled(): pass @celery_cli.command() def mark_old_credit_cards(): pass
"""Perform database admin tasks including migrations using Alembic. """ import logging import sys from flask import current_app from flask.cli import AppGroup import click from . import migrate, pg logger = logging.getLogger(__name__) logger.setLevel(logging.DEBUG) cli = AppGroup(name='db', help='Database Administration') cli.add_command(migrate.cli) cli.add_command(pg.cli) @cli.command() def create_all(): """Create database and objects.""" logger.info('creating all') current_app.extensions['sqlalchemy'].db.create_all() @cli.command() @click.confirmation_option(help='Are you sure you want to drop the db?') def drop_all(): """Drop all database objects (drop_all & create_all).""" if click.confirm('Are you sure you want to drop all data?'):
import os import click from flask.cli import AppGroup from flask import current_app admin_cli = AppGroup('admin') @admin_cli.command('remove') @click.argument('filenames', nargs=-1) def remove_sound(filenames): assets_path = os.path.join(current_app.root_path, 'static', 'assets') for filename in filenames: filepath = os.path.join(assets_path, 'contributions', filename) try: os.remove(filepath) print('Removed ' + filename) except e: click.echo('Cannot remove {}'.format(filename)) filtered_sounds = None contributions_path = os.path.join(assets_path, 'contributions.cvs') with open(contributions_path, 'r') as contrib: filtered_sounds = [ fn for fn in contrib.read().rstrip().split('\n') if fn not in filenames ] with open(contributions_path, 'w') as contrib: contrib.write('\n'.join(filtered_sounds) + '\n')