def main():
_add_project_modules_to_sys_path()
commands = Group(no_args_is_help=True)
for command in SUPPORTED_COMMANDS:
commands.add_command(command, command.name)
click.CommandCollection(sources=[commands])()
def make(cli: click.Group):
@cli.command(name="search")
@click.argument("query", type=click.STRING)
@click.pass_obj
def search(ctx, query):
ctx = config.getctx(ctx)
r = ctx.session.get(
"search",
params={"q": query},
)
if not r.ok:
exit_with(handle_request_error(r))
for result in r.json()["hits"]["hits"]:
click.secho(
f'{result["_source"]["owner_name"]}/', fg="cyan", bold=True, nl=False
)
click.secho(
f'{result["_source"]["workspace_name"]}',
fg="cyan",
bold=True,
nl=False,
)
click.secho(result["_source"]["path"])
cli.add_command(search)
def _get_nested_command(grp: Group, names: Iterable[str]) -> Union[Group, Command]:
"""Recursively find nested command and get it's help."""
if len(names) == 1:
return grp.get_command(Context(grp, info_name=grp.name), names[0])
else:
child_grp = grp.get_command(Context(grp, info_name=grp.name), names[0])
return _get_nested_command(child_grp, names[1:])
def make(cli: click.Group):
@click.command(name="login")
@click.option("--access-key", prompt=True)
@click.option("--secret-key", prompt=True)
@click.pass_obj
def login(ctx, access_key, secret_key):
ctx = config.getctx(ctx)
r = ctx.session.get("user/me", auth=(access_key, secret_key))
if r.ok:
click.echo(click.style("Login success", fg="green", bold=True))
ctx.config.access_key = access_key
ctx.config.secret_key = secret_key
config.save(ctx)
else:
exit_with(handle_request_error(r))
@click.command(name="info")
@click.pass_obj
def me(ctx):
ctx = config.getctx(ctx)
r1 = ctx.session.get("user/me")
if not r1.ok:
exit_with(handle_request_error(r1))
out = r1.json()
out.update(ctx.config.dict())
out.update({"configPath": ctx.configPath})
exit_with(out)
cli.add_command(login)
cli.add_command(me)
def register_to(self, group: click.Group) -> None:
"""
Registers all commands to the given group.
:param group: Click group to register the commands to
"""
for command in self.commands:
group.add_command(command)
def get_command(self, ctx: Context, cmd_name: str) -> Optional[Command]:
rv = Group.get_command(self, ctx, cmd_name)
if rv:
return rv
dashed = cmd_name.replace("_", "-")
for cmd in self.list_commands(ctx):
if cmd == dashed:
return Group.get_command(self, ctx, cmd)
return None
def add_plugin_commands(command_group: click.Group) -> None:
"""
Add commands provided by all plugins to the given command group. Each command is
added with a name that is equal to the plugin name.
"""
for plugin in plugins.iter_installed():
if isinstance(plugin.command, click.Command):
plugin.command.name = plugin.name
command_group.add_command(plugin.command)
def maybe_add_run_to_cli(cli: click.Group) -> None:
if "run" not in cli.commands:
if state.file or state.module:
obj = get_typer_from_state()
if obj:
obj._add_completion = False
click_obj = typer.main.get_command(obj)
click_obj.name = "run"
if not click_obj.help:
click_obj.help = "Run the provided Typer app."
cli.add_command(click_obj)
def get_command(self, ctx, cmd_name):
rv = Group.get_command(self, ctx, cmd_name)
if rv is not None:
return rv
matches = [
x for x in self.list_commands(ctx) if x.startswith(cmd_name)
]
if not matches:
return None
elif len(matches) == 1:
return Group.get_command(self, ctx, matches[0])
ctx.fail('Too many matches: %s' % ', '.join(sorted(matches)))
def make(cli: click.Group):
@cli.group(name="token", cls=ClickAliasedGroup, aliases=["t"])
def token():
pass
@token.command(name="fetch", aliases=["f"])
@click.argument("workspaces", type=click.STRING, nargs=-1)
@click.pass_obj
def create_token(ctx, workspaces):
if len(workspaces) == 0:
return
r = ctx["session"].post("token/search",
json={"search_terms": workspaces})
if r.ok:
response = schemas.S3TokenSearchResponse(**r.json())
for wrapper in response.tokens:
node = wrapper.node
token = wrapper.token
click.secho(
f"Credentials for {[w.name for w in token.workspaces]} @ {node.api_url}",
fg="green",
)
click.secho(
f"Expires in {token.expiration - datetime.utcnow()}\n",
fg="yellow")
click.secho(f"export AWS_ACCESS_KEY_ID={token.access_key_id}")
click.secho(
f"export AWS_SECRET_ACCESS_KEY={token.secret_access_key}")
click.secho(
f"export AWS_SESSION_TOKEN={token.session_token}\n")
else:
exit_with(handle_request_error(r))
@token.command(name="list", aliases=["l", "ls"])
@click.pass_obj
def list_token(ctx):
r = ctx["session"].get("token")
exit_with(handle_request_error(r))
@token.command(name="delete", aliases=["d"])
@click.option("--all", is_flag=True)
@click.argument("token_id", required=False)
@click.pass_obj
def delete_token(ctx, all, token_id):
if all:
r = ctx["session"].delete("token")
else:
r = ctx["session"].delete(f"token/{token_id}")
exit_with(handle_request_error(r))
cli.add_command(token)
def add_command(self, cmd, name=None):
""" Hook the added command and put the group options on the command """
Group.add_command(self, cmd, name=name)
cmd.require_project = '@@ignore_check@@' not in (cmd.callback.__doc__
or "")
# add the group parameters to the command
for param in self.params:
cmd.params.append(param)
# hook the command's invoke with our own
cmd.invoke = self.build_command_invoke(cmd.invoke)
self.invoke_without_command = True
def generate_reference(cli: Group):
with cli.make_context("tokfetch", ["tokfetch"], max_content_width=200, terminal_width=200) as ctx:
main_help = cli.get_help(ctx)
main_help = remove_ansi(main_help)
main_help = textwrap.indent(main_help, " ")
print(TEMPLATE.format(main_help))
for name in sorted(cli.commands.keys()):
cmd = cli.commands[name]
with cli.make_context("tokfetch {}".format(name), ["tokfetch", name]) as subcommand_ctx:
short_help = cmd.help
long_help = cmd.get_help(subcommand_ctx)
long_help = textwrap.indent(long_help, " ")
print(SUBCOMMAND_TEMPLATE.format(name, name, short_help, long_help))
def make(cli: click.Group):
@cli.group(name="index")
def index():
pass
@index.command(name="delete")
@click.argument("root_id", type=click.STRING)
@click.pass_obj
def delete(ctx, root_id):
r = config.getctx(ctx).session.delete(f"root/{root_id}/index")
exit_with(handle_request_error(r))
@index.command(name="create")
@click.argument("root_id", type=click.STRING)
@click.pass_obj
def create(ctx, root_id):
ctx = config.getctx(ctx)
r = ctx.session.post(f"root/{root_id}/index")
r2 = ctx.session.get("info")
if r.ok and r2.ok:
data = r.json()
infodata = r2.json()
root_id = data["root_id"]
bucket = data["root"]["bucket"]
prefix = posixpath.join(data["root"]["base_path"], "/").lstrip("/")
endpoint_base = infodata["public_address"]
click.secho(
"To notify Workspaces of updates, configure your MinIO instance using these commands.\n",
fg="yellow",
)
for c in [
# wehook ID should come from ROOT, not index. You only want to subscribe to events once.
f"export ALIAS=local",
f"mc admin config set $ALIAS notify_webhook:{root_id} endpoint={endpoint_base}/api/minio/events enable=on",
f"mc event add $ALIAS/{bucket} arn:minio:sqs::{root_id}:webhook {f'--prefix {prefix}' if prefix else ''} --event delete,put",
]:
click.secho("\t" + c, fg="blue", bold=True)
click.echo("")
else:
exit_with(handle_request_error(r))
cli.add_command(index)
def test_request_headers(scan_mock: Mock, client):
c = Commit()
c._patch = _SIMPLE_SECRET
with Context(Command("bar"), info_name="bar") as ctx:
ctx.parent = Context(Group("foo"), info_name="foo")
c.scan(
client=client,
cache=Cache(),
matches_ignore={},
all_policies=True,
verbose=False,
)
scan_mock.assert_called_with(
ANY,
{
"GGShield-Version": __version__,
"GGShield-Command-Path": "foo bar",
},
)
def make(cli: click.Group):
@click.command(name="login")
@click.argument("email")
@click.option("--password", prompt=True, hide_input=True)
@click.pass_obj
def login(ctx, email, password):
conf = ctx["config"]
r = ctx["session"].post(
"auth/jwt/login",
{
"username": email,
"password": password,
},
)
if r.ok:
token = r.json()["access_token"]
click.echo(click.style("Login success", fg="green", bold=True))
conf.token = token
save_config(conf, ctx["configPath"])
else:
exit_with(handle_request_error(r))
@click.command(name="register")
@click.argument("email")
@click.argument("username")
@click.option("--password", prompt=True, hide_input=True)
@click.pass_obj
def register(ctx, email, password, username):
r = ctx["session"].post(
"auth/register",
json={
"email": email,
"username": username,
"password": password,
},
)
exit_with(handle_request_error(r))
@click.command(name="info")
@click.pass_obj
def me(ctx):
r = ctx["session"].get("me")
exit_with(handle_request_error(r))
cli.add_command(login)
cli.add_command(register)
cli.add_command(me)
def vdk_command_line(root_command: click.Group) -> None:
root_command.add_command(ingest_csv)
def __init__(self, name=None, commands=[], **attrs):
Group.__init__(self, name, **attrs)
self.commands = OrderedDict(commands)
def add_commands(cli: click.Group) -> None:
cli.add_command(print_model)
import string
import random
import secrets
from click import Group, option
from back.models import helper
ALPHANUMERIC = string.ascii_letters + string.digits
MIN_PLACE_ID_LEN = 20
MAX_PLACE_ID_LEN = 256
db_cli = Group("db")
def generate_place_id():
# See for information about Google place_id https://developers.google.com/places/web-service/place-id
id_len = random.randint(MIN_PLACE_ID_LEN, MAX_PLACE_ID_LEN)
return "".join(secrets.choice(ALPHANUMERIC) for _ in range(id_len))
@db_cli.command("fill")
@option("--likes", default=5, help="Number of likes")
@option("--dislikes", default=5, help="Number of dislikes")
def fill_db(likes, dislikes):
user_data = dict(
first_name="United",
last_name="Remote",
email="*****@*****.**",
password="******"
)
def db_commands(group: click.Group) -> click.Group:
group.add_command(create_all)
group.add_command(drop_all)
return group
from click import Group
manager = Group(help="Manage the database (create/drop tables).")
@manager.command()
def create_tables():
"""Create the database tables."""
from redash.models import create_db, init_db
create_db(True, False)
init_db()
@manager.command()
def drop_tables():
"""Drop the database tables."""
from redash.models import create_db
create_db(False, True)
def invoke_tree(root: click.Group, subcommands: List[str]):
click_ctx = click.get_current_context()
click_ctx.args = subcommands[1:]
click_ctx.protected_args = subcommands[:1]
root.invoke(click_ctx)
def register(cli: click.Group):
cli.add_command(build)
cli.add_command(clean)
cli.add_command(pause)
cli.add_command(print_tokens)
cli.add_command(reset)
cli.add_command(resume)
cli.add_command(run_docker_command)
cli.add_command(scale)
cli.add_command(setup)
cli.add_command(start)
cli.add_command(validate)
cli.add_command(worker)
def register_to(self, group: click.Group) -> None:
for command in self.commands:
group.add_command(command)
def add_commands(command_group: click.Group) -> None:
command_group.add_command(start)
command_group.add_command(stop)
command_group.add_command(restart)
command_group.add_command(reboot)
command_group.add_command(init)
command_group.add_command(createuser)
command_group.add_command(importdemocourse)
command_group.add_command(settheme)
command_group.add_command(dc_command)
command_group.add_command(run)
command_group.add_command(copyfrom)
command_group.add_command(bindmount_command)
command_group.add_command(execute)
command_group.add_command(logs)
command_group.add_command(status)
def make(cli: click.Group):
@cli.group(name="root", cls=ClickAliasedGroup, aliases=["r"])
def root():
pass
@root.command(name="list", aliases=["l", "ls"])
@click.option("--node-name", type=click.STRING)
@click.pass_obj
def list_roots(ctx, node_name):
r = ctx["session"].get("root", params={"node_name": node_name})
exit_with(handle_request_error(r))
@root.command(name="create", aliases=["c"])
@click.argument("bucket", type=click.STRING)
@click.argument("node_name", type=click.STRING)
@click.option("--base-path", type=click.STRING, default="")
@click.option(
"--root-type",
type=click.Choice(schemas.RootType),
default=schemas.RootType.PRIVATE.value,
)
@click.pass_obj
def create_root(ctx, bucket, node_name, base_path, root_type):
r = ctx["session"].post(
"root",
json={
"bucket": bucket,
"node_name": node_name,
"base_path": base_path,
"root_type": root_type,
},
)
exit_with(handle_request_error(r))
@root.command(name="delete", aliases=["d"])
@click.argument("root_id", type=click.STRING)
@click.pass_obj
def delete_root(ctx, root_id):
r = ctx["session"].delete(f"root/{root_id}")
exit_with(handle_request_error(r))
@root.command(name="import", help="Import all workspaces in a root.")
@click.argument("root_id")
@click.option("--index-all", is_flag=True)
@click.pass_obj
def import_all_workspaces(ctx, root_id, index_all):
# Dynamic, expensive imports
from workspacesio.common import producers
ctx = config.getctx(ctx)
r = ctx.session.post(f"root/{root_id}/import")
if not r.ok:
exit_with(handle_request_error(r))
rdata = schemas.RootCredentials(**r.json())
root_contents = producers.minio_list_root_children(node=rdata.node,
root=rdata.root)
workspace_list: List[schemas.WorkspaceDB] = []
for folder in root_contents:
prefix = folder.object_name.lstrip(rdata.root.base_path).strip("/")
if len(prefix) > 0:
print(f"Discovered {prefix}")
workspace = ctx.session.post(
"workspace",
json={
"name": prefix,
"public": False,
"unmanaged": True,
"base_path": prefix,
"node_name": rdata.node.name,
"root_id": str(rdata.root.id),
},
)
if not workspace.ok and workspace.status_code != 409:
exit_with(handle_request_error(workspace))
workspace_list.append(schemas.WorkspaceDB(**workspace.json()))
@root.command(name="import-workspace",
help="Import a particular prefix as a workspace.")
@click.argument("root_id", type=click.STRING)
@click.argument("--base-path", type=click.STRING, default="")
def import_workspace(ctx, root_id, base_path):
pass
cli.add_command(root)
def pytask_extend_command_line_interface(cli: click.Group) -> None:
"""Extend the command line interface."""
cli.add_command(clean)
def __init__(
self,
cli: click.Group,
pipeline_func: Callable,
services: PlatformServicesBase,
image_url: str,
package_entrypoint: str,
op_builders: List[Callable[[HmlContainerOp], HmlContainerOp]],
envs: Dict[str, str],
):
if cli is None:
raise (TypeError("Parameter: `cli` must be supplied"))
if pipeline_func is None:
raise (TypeError("Parameter: `pipeline_func` must be supplied"))
if services is None:
raise (TypeError("Parameter: `services` must be supplied"))
if image_url is None or image_url == "":
raise (TypeError("Parameter: `image_url` must be supplied"))
if package_entrypoint is None or package_entrypoint == "":
raise (
TypeError("Parameter: `package_entrypoint` must be supplied"))
self.name = pipeline_func.__name__
self.envs: Dict[str, str] = envs
self.services = services
self.pipeline_func = pipeline_func
self.kubeflow_pipeline = dsl.pipeline(pipeline_func,
pipeline_func.__name__)
self.is_deploying = False
self.cron: Optional[str] = None
self.experiment: Optional[str] = None
self.image_url = image_url
self.package_entrypoint = package_entrypoint
# The methods we use to configure our Ops for running in Kubeflow
self.op_builders = op_builders
self.ops_list: List[HmlContainerOp] = []
self.ops_dict: Dict[str, HmlContainerOp] = {}
# We treat the pipeline as a "group" of commands, rather than actually executing
# anything. We can then bind a
self.cli_pipeline = click.group(name=pipeline_func.__name__)(_pass)
# Register this with the root `pipeline` command
cli.add_command(self.cli_pipeline)
# Create a command to execute the whole pipeline
self.cli_all = click.command(name="run-all")(self.run_all)
self.deploy_dev = self._apply_deploy_options(
click.command(name="deploy-dev")(self._deploy_dev))
self.deploy_prod = self._apply_deploy_options(
click.command(name="deploy-prod")(self._deploy_prod))
self.cli_pipeline.add_command(self.cli_all)
self.cli_pipeline.add_command(self.deploy_dev)
self.cli_pipeline.add_command(self.deploy_prod)
from sys import exit
from click import Group, argument, option
from redash import models
manager = Group(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)
print "permissions: [%s]" % ",".join(permissions)
try:
models.Group.create(name=name, org=org, permissions=permissions)
except Exception, e:
from click import Group from cli.start import start from cli.stop import stop from cli.logs import logs from cli.build import build from cli.kill import kill cli = Group() cli.add_command(start) cli.add_command(stop) cli.add_command(logs) cli.add_command(build) cli.add_command(kill)
from os import environ
from click import Group, option, echo, secho, style
from pathlib import Path
from sparrow import Database
from .et_redux_importer import ETReduxImporter
from .import_metadata import import_metadata
cli = Group()
@cli.command(name="import-xml")
@option("--fix-errors", is_flag=True, default=False)
@option("--redo", is_flag=True, default=False)
def import_xml(**kwargs):
"""
Import Boise State XML files
"""
varname = "SPARROW_DATA_DIR"
env = environ.get(varname, None)
if env is None:
v = style(varname, fg="cyan", bold=True)
echo(f"Environment variable {v} is not set.")
secho("Aborting", fg="red", bold=True)
return
path = Path(env)
assert path.is_dir()
db = Database()
importer = ETReduxImporter(db)
files = path.glob("**/*.xml")
