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')
