Search is not available for this dataset
text
stringlengths 75
104k
|
|---|
def statuses(ctx, page):
"""Get job statuses.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
\b
```bash
$ polyaxon job -j 2 statuses
```
"""
user, project_name, _job = get_job_or_local(ctx.obj.get('project'), ctx.obj.get('job'))
page = page or 1
try:
response = PolyaxonClient().job.get_statuses(user, project_name, _job, page=page)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not get status for job `{}`.'.format(_job))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
meta = get_meta_response(response)
if meta:
Printer.print_header('Statuses for Job `{}`.'.format(_job))
Printer.print_header('Navigation:')
dict_tabulate(meta)
else:
Printer.print_header('No statuses found for job `{}`.'.format(_job))
objects = list_dicts_to_tabulate(
[Printer.add_status_color(o.to_light_dict(humanize_values=True), status_key='status')
for o in response['results']])
if objects:
Printer.print_header("Statuses:")
objects.pop('job', None)
dict_tabulate(objects, is_list_dict=True) |
def resources(ctx, gpu):
"""Get job resources.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
\b
```bash
$ polyaxon job -j 2 resources
```
For GPU resources
\b
```bash
$ polyaxon job -j 2 resources --gpu
```
"""
user, project_name, _job = get_job_or_local(ctx.obj.get('project'), ctx.obj.get('job'))
try:
message_handler = Printer.gpu_resources if gpu else Printer.resources
PolyaxonClient().job.resources(user,
project_name,
_job,
message_handler=message_handler)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not get resources for job `{}`.'.format(_job))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1) |
def logs(ctx, past, follow, hide_time):
"""Get job logs.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
\b
```bash
$ polyaxon job -j 2 logs
```
\b
```bash
$ polyaxon job logs
```
"""
user, project_name, _job = get_job_or_local(ctx.obj.get('project'), ctx.obj.get('job'))
if past:
try:
response = PolyaxonClient().job.logs(
user, project_name, _job, stream=False)
get_logs_handler(handle_job_info=False,
show_timestamp=not hide_time,
stream=False)(response.content.decode().split('\n'))
print()
if not follow:
return
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
if not follow:
Printer.print_error('Could not get logs for job `{}`.'.format(_job))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
try:
PolyaxonClient().job.logs(
user,
project_name,
_job,
message_handler=get_logs_handler(handle_job_info=False, show_timestamp=not hide_time))
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not get logs for job `{}`.'.format(_job))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1) |
def outputs(ctx):
"""Download outputs for job.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
\b
```bash
$ polyaxon job -j 1 outputs
```
"""
user, project_name, _job = get_job_or_local(ctx.obj.get('project'), ctx.obj.get('job'))
try:
PolyaxonClient().job.download_outputs(user, project_name, _job)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not download outputs for job `{}`.'.format(_job))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
Printer.print_success('Files downloaded.') |
def pprint(value):
"""Prints as formatted JSON"""
click.echo(
json.dumps(value,
sort_keys=True,
indent=4,
separators=(',', ': '))) |
def login(token, username, password):
"""Login to Polyaxon."""
auth_client = PolyaxonClient().auth
if username:
# Use username / password login
if not password:
password = click.prompt('Please enter your password', type=str, hide_input=True)
password = password.strip()
if not password:
logger.info('You entered an empty string. '
'Please make sure you enter your password correctly.')
sys.exit(1)
credentials = CredentialsConfig(username=username, password=password)
try:
access_code = auth_client.login(credentials=credentials)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not login.')
Printer.print_error('Error Message `{}`.'.format(e))
sys.exit(1)
if not access_code:
Printer.print_error("Failed to login")
return
else:
if not token:
token_url = "{}/app/token".format(auth_client.config.http_host)
click.confirm('Authentication token page will now open in your browser. Continue?',
abort=True, default=True)
click.launch(token_url)
logger.info("Please copy and paste the authentication token.")
token = click.prompt('This is an invisible field. Paste token and press ENTER',
type=str, hide_input=True)
if not token:
logger.info("Empty token received. "
"Make sure your shell is handling the token appropriately.")
logger.info("See docs for help: http://docs.polyaxon.com/polyaxon_cli/commands/auth")
return
access_code = token.strip(" ")
# Set user
try:
AuthConfigManager.purge()
user = PolyaxonClient().auth.get_user(token=access_code)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not load user info.')
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
access_token = AccessTokenConfig(username=user.username, token=access_code)
AuthConfigManager.set_config(access_token)
Printer.print_success("Login successful")
# Reset current cli
server_version = get_server_version()
current_version = get_current_version()
log_handler = get_log_handler()
CliConfigManager.reset(check_count=0,
current_version=current_version,
min_version=server_version.min_version,
log_handler=log_handler) |
def whoami():
"""Show current logged Polyaxon user."""
try:
user = PolyaxonClient().auth.get_user()
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not load user info.')
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
click.echo("\nUsername: {username}, Email: {email}\n".format(**user.to_dict())) |
def build(ctx, project, build): # pylint:disable=redefined-outer-name
"""Commands for build jobs."""
ctx.obj = ctx.obj or {}
ctx.obj['project'] = project
ctx.obj['build'] = build |
def get(ctx):
"""Get build job.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
\b
```bash
$ polyaxon build -b 1 get
```
\b
```bash
$ polyaxon build --build=1 --project=project_name get
```
"""
user, project_name, _build = get_build_or_local(ctx.obj.get('project'), ctx.obj.get('build'))
try:
response = PolyaxonClient().build_job.get_build(user, project_name, _build)
cache.cache(config_manager=BuildJobManager, response=response)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not get build job `{}`.'.format(_build))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
get_build_details(response) |
def delete(ctx):
"""Delete build job.
Uses [Caching](/references/polyaxon-cli/#caching)
Example:
\b
```bash
$ polyaxon build delete
```
\b
```bash
$ polyaxon build -b 2 delete
```
"""
user, project_name, _build = get_build_or_local(ctx.obj.get('project'), ctx.obj.get('build'))
if not click.confirm("Are sure you want to delete build job `{}`".format(_build)):
click.echo('Existing without deleting build job.')
sys.exit(1)
try:
response = PolyaxonClient().build_job.delete_build(
user, project_name, _build)
# Purge caching
BuildJobManager.purge()
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not delete job `{}`.'.format(_build))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
if response.status_code == 204:
Printer.print_success("Build job `{}` was deleted successfully".format(_build)) |
def update(ctx, name, description, tags):
"""Update build.
Uses [Caching](/references/polyaxon-cli/#caching)
Example:
\b
```bash
$ polyaxon build -b 2 update --description="new description for my build"
```
"""
user, project_name, _build = get_build_or_local(ctx.obj.get('project'), ctx.obj.get('build'))
update_dict = {}
if name:
update_dict['name'] = name
if description:
update_dict['description'] = description
tags = validate_tags(tags)
if tags:
update_dict['tags'] = tags
if not update_dict:
Printer.print_warning('No argument was provided to update the build.')
sys.exit(0)
try:
response = PolyaxonClient().build_job.update_build(
user, project_name, _build, update_dict)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not update build `{}`.'.format(_build))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
Printer.print_success("Build updated.")
get_build_details(response) |
def stop(ctx, yes):
"""Stop build job.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
\b
```bash
$ polyaxon build stop
```
\b
```bash
$ polyaxon build -b 2 stop
```
"""
user, project_name, _build = get_build_or_local(ctx.obj.get('project'), ctx.obj.get('build'))
if not yes and not click.confirm("Are sure you want to stop "
"job `{}`".format(_build)):
click.echo('Existing without stopping build job.')
sys.exit(0)
try:
PolyaxonClient().build_job.stop(user, project_name, _build)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not stop build job `{}`.'.format(_build))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
Printer.print_success("Build job is being stopped.") |
def bookmark(ctx):
"""Bookmark build job.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
\b
```bash
$ polyaxon build bookmark
```
\b
```bash
$ polyaxon build -b 2 bookmark
```
"""
user, project_name, _build = get_build_or_local(ctx.obj.get('project'), ctx.obj.get('build'))
try:
PolyaxonClient().build_job.bookmark(user, project_name, _build)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not bookmark build job `{}`.'.format(_build))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
Printer.print_success("Build job bookmarked.") |
def resources(ctx, gpu):
"""Get build job resources.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
\b
```bash
$ polyaxon build -b 2 resources
```
For GPU resources
\b
```bash
$ polyaxon build -b 2 resources --gpu
```
"""
user, project_name, _build = get_build_or_local(ctx.obj.get('project'), ctx.obj.get('build'))
try:
message_handler = Printer.gpu_resources if gpu else Printer.resources
PolyaxonClient().build_job.resources(user,
project_name,
_build,
message_handler=message_handler)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not get resources for build job `{}`.'.format(_build))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1) |
def init(project, polyaxonfile):
"""Initialize a new polyaxonfile specification."""
user, project_name = get_project_or_local(project)
try:
project_config = PolyaxonClient().project.get_project(user, project_name)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Make sure you have a project with this name `{}`'.format(project))
Printer.print_error(
'You can a create new project with this command: '
'polyaxon project create '
'--name={} [--description=...] [--tags=...]'.format(project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
init_project = False
if ProjectManager.is_initialized():
local_project = ProjectManager.get_config()
click.echo('Warning! This project is already initialized with the following project:')
with clint.textui.indent(4):
clint.textui.puts('User: {}'.format(local_project.user))
clint.textui.puts('Project: {}'.format(local_project.name))
if click.confirm('Would you like to override this current config?', default=False):
init_project = True
else:
init_project = True
if init_project:
ProjectManager.purge()
ProjectManager.set_config(project_config, init=True)
Printer.print_success('Project was initialized')
else:
Printer.print_header('Project config was not changed.')
init_ignore = False
if IgnoreManager.is_initialized():
click.echo('Warning! Found a .polyaxonignore file.')
if click.confirm('Would you like to override it?', default=False):
init_ignore = True
else:
init_ignore = True
if init_ignore:
IgnoreManager.init_config()
Printer.print_success('New .polyaxonignore file was created.')
else:
Printer.print_header('.polyaxonignore file was not changed.')
if polyaxonfile:
create_polyaxonfile() |
def run(ctx, project, file, name, tags, description, ttl, u, l): # pylint:disable=redefined-builtin
"""Run polyaxonfile specification.
Examples:
\b
```bash
$ polyaxon run -f file -f file_override ...
```
Upload before running
\b
```bash
$ polyaxon run -f file -u
```
Run and set description and tags for this run
\b
```bash
$ polyaxon run -f file -u --description="Description of the current run" --tags="foo, bar, moo"
```
Run and set a unique name for this run
\b
```bash
polyaxon run --name=foo
```
Run for a specific project
\b
```bash
$ polyaxon run -p project1 -f file.yaml
```
"""
if not file:
file = PolyaxonFile.check_default_path(path='.')
if not file:
file = ''
specification = check_polyaxonfile(file, log=False).specification
spec_cond = (specification.is_experiment or
specification.is_group or
specification.is_job or
specification.is_build)
if not spec_cond:
Printer.print_error(
'This command expects an experiment, a group, a job, or a build specification,'
'received instead a `{}` specification'.format(specification.kind))
if specification.is_notebook:
click.echo('Please check "polyaxon notebook --help" to start a notebook.')
elif specification.is_tensorboard:
click.echo('Please check: "polyaxon tensorboard --help" to start a tensorboard.')
sys.exit(1)
# Check if we need to upload
if u:
if project:
Printer.print_error('Uploading is not supported when switching project context!')
click.echo('Please, either omit the `-u` option or `-p` / `--project=` option.')
sys.exit(1)
ctx.invoke(upload, sync=False)
user, project_name = get_project_or_local(project)
project_client = PolyaxonClient().project
tags = validate_tags(tags)
def run_experiment():
click.echo('Creating an independent experiment.')
experiment = ExperimentConfig(
name=name,
description=description,
tags=tags,
config=specification.parsed_data,
ttl=ttl)
try:
response = PolyaxonClient().project.create_experiment(user,
project_name,
experiment)
cache.cache(config_manager=ExperimentManager, response=response)
Printer.print_success('Experiment `{}` was created'.format(response.id))
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not create experiment.')
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
def run_group():
click.echo('Creating an experiment group with the following definition:')
experiments_def = specification.experiments_def
get_group_experiments_info(**experiments_def)
experiment_group = ExperimentGroupConfig(
name=name,
description=description,
tags=tags,
content=specification._data) # pylint:disable=protected-access
try:
response = project_client.create_experiment_group(user,
project_name,
experiment_group)
cache.cache(config_manager=GroupManager, response=response)
Printer.print_success('Experiment group {} was created'.format(response.id))
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not create experiment group.')
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
def run_job():
click.echo('Creating a job.')
job = JobConfig(
name=name,
description=description,
tags=tags,
config=specification.parsed_data,
ttl=ttl)
try:
response = project_client.create_job(user,
project_name,
job)
cache.cache(config_manager=JobManager, response=response)
Printer.print_success('Job {} was created'.format(response.id))
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not create job.')
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
def run_build():
click.echo('Creating a build.')
job = JobConfig(
name=name,
description=description,
tags=tags,
config=specification.parsed_data,
ttl=ttl)
try:
response = project_client.create_build(user,
project_name,
job)
cache.cache(config_manager=BuildJobManager, response=response)
Printer.print_success('Build {} was created'.format(response.id))
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not create build.')
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
logs = None
if specification.is_experiment:
run_experiment()
logs = experiment_logs
elif specification.is_group:
run_group()
elif specification.is_job:
run_job()
logs = job_logs
elif specification.is_build:
run_build()
logs = build_logs
# Check if we need to invoke logs
if l and logs:
ctx.obj = {'project': '{}/{}'.format(user, project_name)}
ctx.invoke(logs) |
def bookmark(ctx, username): # pylint:disable=redefined-outer-name
"""Commands for bookmarks."""
ctx.obj = ctx.obj or {}
ctx.obj['username'] = username |
def projects(ctx, page):
"""List bookmarked projects for user.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
\b
```bash
$ polyaxon bookmark projects
```
\b
```bash
$ polyaxon bookmark -u adam projects
```
"""
user = get_username_or_local(ctx.obj.get('username'))
page = page or 1
try:
response = PolyaxonClient().bookmark.projects(username=user, page=page)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error(
'Could not get bookmarked projects for user `{}`.'.format(user))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
meta = get_meta_response(response)
if meta:
Printer.print_header('Bookmarked projects for user `{}`.'.format(user))
Printer.print_header('Navigation:')
dict_tabulate(meta)
else:
Printer.print_header('No bookmarked projects found for user `{}`.'.format(user))
objects = [Printer.add_status_color(o.to_light_dict(humanize_values=True))
for o in response['results']]
objects = list_dicts_to_tabulate(objects)
if objects:
Printer.print_header("Projects:")
dict_tabulate(objects, is_list_dict=True) |
def _remove_trailing_spaces(line):
"""Remove trailing spaces unless they are quoted with a backslash."""
while line.endswith(' ') and not line.endswith('\\ '):
line = line[:-1]
return line.replace('\\ ', ' ') |
def find_matching(cls, path, patterns):
"""Yield all matching patterns for path."""
for pattern in patterns:
if pattern.match(path):
yield pattern |
def is_ignored(cls, path, patterns):
"""Check whether a path is ignored. For directories, include a trailing slash."""
status = None
for pattern in cls.find_matching(path, patterns):
status = pattern.is_exclude
return status |
def _matches_patterns(path, patterns):
"""Given a list of patterns, returns a if a path matches any pattern."""
for glob in patterns:
try:
if PurePath(path).match(glob):
return True
except TypeError:
pass
return False |
def _ignore_path(cls, path, ignore_list=None, white_list=None):
"""Returns a whether a path should be ignored or not."""
ignore_list = ignore_list or []
white_list = white_list or []
return (cls._matches_patterns(path, ignore_list) and
not cls._matches_patterns(path, white_list)) |
def group(ctx, project, group): # pylint:disable=redefined-outer-name
"""Commands for experiment groups."""
ctx.obj = ctx.obj or {}
ctx.obj['project'] = project
ctx.obj['group'] = group |
def get(ctx):
"""Get experiment group by uuid.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
\b
```bash
$ polyaxon group -g 13 get
```
"""
user, project_name, _group = get_project_group_or_local(ctx.obj.get('project'),
ctx.obj.get('group'))
try:
response = PolyaxonClient().experiment_group.get_experiment_group(
user, project_name, _group)
cache.cache(config_manager=GroupManager, response=response)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not get experiment group `{}`.'.format(_group))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
get_group_details(response) |
def delete(ctx):
"""Delete experiment group.
Uses [Caching](/references/polyaxon-cli/#caching)
"""
user, project_name, _group = get_project_group_or_local(ctx.obj.get('project'),
ctx.obj.get('group'))
if not click.confirm("Are sure you want to delete experiment group `{}`".format(_group)):
click.echo('Existing without deleting experiment group.')
sys.exit(0)
try:
response = PolyaxonClient().experiment_group.delete_experiment_group(
user, project_name, _group)
# Purge caching
GroupManager.purge()
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not delete experiment group `{}`.'.format(_group))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
if response.status_code == 204:
Printer.print_success("Experiment group `{}` was delete successfully".format(_group)) |
def update(ctx, name, description, tags):
"""Update experiment group.
Uses [Caching](/references/polyaxon-cli/#caching)
Example:
\b
```bash
$ polyaxon group -g 2 update --description="new description for this group"
```
\b
```bash
$ polyaxon update --tags="foo, bar"
```
"""
user, project_name, _group = get_project_group_or_local(ctx.obj.get('project'),
ctx.obj.get('group'))
update_dict = {}
if name:
update_dict['name'] = name
if description:
update_dict['description'] = description
tags = validate_tags(tags)
if tags:
update_dict['tags'] = tags
if not update_dict:
Printer.print_warning('No argument was provided to update the experiment group.')
sys.exit(0)
try:
response = PolyaxonClient().experiment_group.update_experiment_group(
user, project_name, _group, update_dict)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not update experiment group `{}`.'.format(_group))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
Printer.print_success("Experiment group updated.")
get_group_details(response) |
def stop(ctx, yes, pending):
"""Stop experiments in the group.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples: stop only pending experiments
\b
```bash
$ polyaxon group stop --pending
```
Examples: stop all unfinished
\b
```bash
$ polyaxon group stop
```
\b
```bash
$ polyaxon group -g 2 stop
```
"""
user, project_name, _group = get_project_group_or_local(ctx.obj.get('project'),
ctx.obj.get('group'))
if not yes and not click.confirm("Are sure you want to stop experiments "
"in group `{}`".format(_group)):
click.echo('Existing without stopping experiments in group.')
sys.exit(0)
try:
PolyaxonClient().experiment_group.stop(user, project_name, _group, pending=pending)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not stop experiments in group `{}`.'.format(_group))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
Printer.print_success("Experiments in group are being stopped.") |
def bookmark(ctx):
"""Bookmark group.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
\b
```bash
$ polyaxon group bookmark
```
\b
```bash
$ polyaxon group -g 2 bookmark
```
"""
user, project_name, _group = get_project_group_or_local(ctx.obj.get('project'),
ctx.obj.get('group'))
try:
PolyaxonClient().experiment_group.bookmark(user, project_name, _group)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not bookmark group `{}`.'.format(_group))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
Printer.print_success("Experiments group is bookmarked.") |
def config(list): # pylint:disable=redefined-builtin
"""Set and get the global configurations."""
if list:
_config = GlobalConfigManager.get_config_or_default()
Printer.print_header('Current config:')
dict_tabulate(_config.to_dict()) |
def get(keys):
"""Get the global config values by keys.
Example:
\b
```bash
$ polyaxon config get host http_port
```
"""
_config = GlobalConfigManager.get_config_or_default()
if not keys:
return
print_values = {}
for key in keys:
if hasattr(_config, key):
print_values[key] = getattr(_config, key)
else:
click.echo('Key `{}` is not recognised.'.format(key))
dict_tabulate(print_values, ) |
def set(verbose, # pylint:disable=redefined-builtin
host,
http_port,
ws_port,
use_https,
verify_ssl):
"""Set the global config values.
Example:
\b
```bash
$ polyaxon config set --hots=localhost http_port=80
```
"""
_config = GlobalConfigManager.get_config_or_default()
if verbose is not None:
_config.verbose = verbose
if host is not None:
_config.host = host
if http_port is not None:
_config.http_port = http_port
if ws_port is not None:
_config.ws_port = ws_port
if use_https is not None:
_config.use_https = use_https
if verify_ssl is False:
_config.verify_ssl = verify_ssl
GlobalConfigManager.set_config(_config)
Printer.print_success('Config was updated.')
# Reset cli config
CliConfigManager.purge() |
def activate(username):
"""Activate a user.
Example:
\b
```bash
$ polyaxon user activate david
```
"""
try:
PolyaxonClient().user.activate_user(username)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not activate user `{}`.'.format(username))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
Printer.print_success("User `{}` was activated successfully.".format(username)) |
def delete(username):
"""Delete a user.
Example:
\b
```bash
$ polyaxon user delete david
```
"""
try:
PolyaxonClient().user.delete_user(username)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not delete user `{}`.'.format(username))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
Printer.print_success("User `{}` was deleted successfully.".format(username)) |
def deploy(file, manager_path, check, dry_run): # pylint:disable=redefined-builtin
"""Deploy polyaxon."""
config = read_deployment_config(file)
manager = DeployManager(config=config,
filepath=file,
manager_path=manager_path,
dry_run=dry_run)
exception = None
if check:
manager.check()
Printer.print_success('Polyaxon deployment file is valid.')
else:
try:
manager.install()
except Exception as e:
Printer.print_error('Polyaxon could not be installed.')
exception = e
if exception:
Printer.print_error('Error message `{}`.'.format(exception)) |
def teardown(file): # pylint:disable=redefined-builtin
"""Teardown a polyaxon deployment given a config file."""
config = read_deployment_config(file)
manager = DeployManager(config=config, filepath=file)
exception = None
try:
if click.confirm('Would you like to execute pre-delete hooks?', default=True):
manager.teardown(hooks=True)
else:
manager.teardown(hooks=False)
except Exception as e:
Printer.print_error('Polyaxon could not teardown the deployment.')
exception = e
if exception:
Printer.print_error('Error message `{}`.'.format(exception)) |
def create_tarfile(files, project_name):
"""Create a tar file based on the list of files passed"""
fd, filename = tempfile.mkstemp(prefix="polyaxon_{}".format(project_name), suffix='.tar.gz')
with tarfile.open(filename, "w:gz") as tar:
for f in files:
tar.add(f)
yield filename
# clear
os.close(fd)
os.remove(filename) |
def url(ctx):
"""Prints the tensorboard url for project/experiment/experiment group.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples for project tensorboards:
\b
```bash
$ polyaxon tensorboard url
```
\b
```bash
$ polyaxon tensorboard -p mnist url
```
Examples for experiment tensorboards:
\b
```bash
$ polyaxon tensorboard -xp 1 url
```
Examples for experiment group tensorboards:
\b
```bash
$ polyaxon tensorboard -g 1 url
```
"""
user, project_name = get_project_or_local(ctx.obj.get('project'))
group = ctx.obj.get('group')
experiment = ctx.obj.get('experiment')
if experiment:
try:
response = PolyaxonClient().experiment.get_experiment(
username=user,
project_name=project_name,
experiment_id=experiment)
obj = 'experiment {}'.format(experiment)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not get experiment `{}`.'.format(experiment))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
elif group:
try:
response = PolyaxonClient().experiment_group.get_experiment_group(
username=user,
project_name=project_name,
group_id=group)
obj = 'group `{}`.'.format(group)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not get group `{}`.'.format(group))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
else:
try:
response = PolyaxonClient().project.get_project(
username=user,
project_name=project_name)
obj = 'project `{}`.'.format(project_name)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not get project `{}`.'.format(project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
if response.has_tensorboard:
click.echo(get_tensorboard_url(user=user,
project_name=project_name,
experiment=experiment,
group=group))
else:
Printer.print_warning('This `{}` does not have a running tensorboard'.format(obj))
click.echo('You can start tensorboard with this command: polyaxon tensorboard start --help') |
def start(ctx, file): # pylint:disable=redefined-builtin
"""Start a tensorboard deployment for project/experiment/experiment group.
Project tensorboard will aggregate all experiments under the project.
Experiment group tensorboard will aggregate all experiments under the group.
Experiment tensorboard will show all metrics for an experiment.
Uses [Caching](/references/polyaxon-cli/#caching)
Example: using the default tensorflow image 1.4.1.
\b
```bash
$ polyaxon tensorboard start
```
Example: with custom image and resources
\b
```bash
$ polyaxon tensorboard start -f file -f file_override ...
```
Example: starting a tensorboard for an experiment group
\b
```bash
$ polyaxon tensorboard -g 1 start -f file
```
Example: starting a tensorboard for an experiment
\b
```bash
$ polyaxon tensorboard -xp 112 start -f file
```
"""
specification = None
job_config = None
if file:
specification = check_polyaxonfile(file, log=False).specification
if specification:
# pylint:disable=protected-access
check_polyaxonfile_kind(specification=specification, kind=specification._TENSORBOARD)
job_config = specification.parsed_data
user, project_name = get_project_or_local(ctx.obj.get('project'))
group = ctx.obj.get('group')
experiment = ctx.obj.get('experiment')
if experiment:
try:
response = PolyaxonClient().experiment.start_tensorboard(
username=user,
project_name=project_name,
experiment_id=experiment,
job_config=job_config)
obj = 'experiment `{}`'.format(experiment)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not start tensorboard experiment `{}`.'.format(experiment))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
elif group:
try:
response = PolyaxonClient().experiment_group.start_tensorboard(
username=user,
project_name=project_name,
group_id=group,
job_config=job_config)
obj = 'group `{}`'.format(group)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not start tensorboard group `{}`.'.format(group))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
else:
try:
response = PolyaxonClient().project.start_tensorboard(
username=user,
project_name=project_name,
job_config=job_config)
obj = 'project `{}`'.format(project_name)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not start tensorboard project `{}`.'.format(project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
if response.status_code == 200:
Printer.print_header("A tensorboard for this {} is already running on:".format(obj))
click.echo(get_tensorboard_url(user=user,
project_name=project_name,
experiment=experiment,
group=group))
sys.exit(0)
if response.status_code != 201:
Printer.print_error('Something went wrong, Tensorboard was not created.')
sys.exit(1)
Printer.print_success('Tensorboard is being deployed for {}'.format(obj))
clint.textui.puts("It may take some time before you can access tensorboard.\n")
clint.textui.puts("Your tensorboard will be available on:\n")
with clint.textui.indent(4):
clint.textui.puts(get_tensorboard_url(user, project_name, experiment, group)) |
def stop(ctx, yes):
"""Stops the tensorboard deployment for project/experiment/experiment group if it exists.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples: stopping project tensorboard
\b
```bash
$ polyaxon tensorboard stop
```
Examples: stopping experiment group tensorboard
\b
```bash
$ polyaxon tensorboard -g 1 stop
```
Examples: stopping experiment tensorboard
\b
```bash
$ polyaxon tensorboard -xp 112 stop
```
"""
user, project_name = get_project_or_local(ctx.obj.get('project'))
group = ctx.obj.get('group')
experiment = ctx.obj.get('experiment')
if experiment:
obj = 'experiment `{}`'.format(experiment)
elif group:
obj = 'group `{}`'.format(group)
else:
obj = 'project `{}/{}`'.format(user, project_name)
if not yes and not click.confirm("Are sure you want to stop tensorboard "
"for {}".format(obj)):
click.echo('Existing without stopping tensorboard.')
sys.exit(1)
if experiment:
try:
PolyaxonClient().experiment.stop_tensorboard(
username=user,
project_name=project_name,
experiment_id=experiment)
Printer.print_success('Tensorboard is being deleted')
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not stop tensorboard {}.'.format(obj))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
elif group:
try:
PolyaxonClient().experiment_group.stop_tensorboard(
username=user,
project_name=project_name,
group_id=group)
Printer.print_success('Tensorboard is being deleted')
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not stop tensorboard {}.'.format(obj))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
else:
try:
PolyaxonClient().project.stop_tensorboard(
username=user,
project_name=project_name)
Printer.print_success('Tensorboard is being deleted')
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not stop tensorboard {}.'.format(obj))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1) |
def check_cli_version():
"""Check if the current cli version satisfies the server requirements"""
if not CliConfigManager.should_check():
return
server_version = get_server_version()
current_version = get_current_version()
CliConfigManager.reset(current_version=current_version,
min_version=server_version.min_version)
if LooseVersion(current_version) < LooseVersion(server_version.min_version):
click.echo("""Your version of CLI ({}) is no longer compatible with server.""".format(
current_version))
if click.confirm("Do you want to upgrade to "
"version {} now?".format(server_version.latest_version)):
pip_upgrade()
sys.exit(0)
else:
clint.textui.puts("Your can manually run:")
with clint.textui.indent(4):
clint.textui.puts("pip install -U polyaxon-cli")
clint.textui.puts(
"to upgrade to the latest version `{}`".format(server_version.latest_version))
sys.exit(0)
elif LooseVersion(current_version) < LooseVersion(server_version.latest_version):
clint.textui.puts("New version of CLI ({}) is now available. To upgrade run:".format(
server_version.latest_version
))
with clint.textui.indent(4):
clint.textui.puts("pip install -U polyaxon-cli")
elif LooseVersion(current_version) > LooseVersion(server_version.latest_version):
clint.textui.puts("You version of CLI ({}) is ahead of the latest version "
"supported by Polyaxon Platform ({}) on your cluster, "
"and might be incompatible.".format(current_version,
server_version.latest_version)) |
def version(cli, platform):
"""Print the current version of the cli and platform."""
version_client = PolyaxonClient().version
cli = cli or not any([cli, platform])
if cli:
try:
server_version = version_client.get_cli_version()
except AuthorizationError:
session_expired()
sys.exit(1)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not get cli version.')
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
cli_version = get_version(PROJECT_CLI_NAME)
Printer.print_header('Current cli version: {}.'.format(cli_version))
Printer.print_header('Supported cli versions:')
dict_tabulate(server_version.to_dict())
if platform:
try:
platform_version = version_client.get_platform_version()
except AuthorizationError:
session_expired()
sys.exit(1)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not get platform version.')
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
chart_version = version_client.get_chart_version()
Printer.print_header('Current platform version: {}.'.format(chart_version.version))
Printer.print_header('Supported platform versions:')
dict_tabulate(platform_version.to_dict()) |
def dashboard(yes, url):
"""Open dashboard in browser."""
dashboard_url = "{}/app".format(PolyaxonClient().api_config.http_host)
if url:
click.echo(dashboard_url)
sys.exit(0)
if not yes:
click.confirm('Dashboard page will now open in your browser. Continue?',
abort=True, default=True)
click.launch(dashboard_url) |
def grant(username):
"""Grant superuser role to a user.
Example:
\b
```bash
$ polyaxon superuser grant david
```
"""
try:
PolyaxonClient().user.grant_superuser(username)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not grant superuser role to user `{}`.'.format(username))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
Printer.print_success(
"Superuser role was granted successfully to user `{}`.".format(username)) |
def revoke(username):
"""Revoke superuser role to a user.
Example:
\b
```bash
$ polyaxon superuser revoke david
```
"""
try:
PolyaxonClient().user.revoke_superuser(username)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not revoke superuser role from user `{}`.'.format(username))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
Printer.print_success(
"Superuser role was revoked successfully from user `{}`.".format(username)) |
def url(ctx):
"""Prints the notebook url for this project.
Uses [Caching](/references/polyaxon-cli/#caching)
Example:
\b
```bash
$ polyaxon notebook url
```
"""
user, project_name = get_project_or_local(ctx.obj.get('project'))
try:
response = PolyaxonClient().project.get_project(user, project_name)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not get project `{}`.'.format(project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
if response.has_notebook:
click.echo(get_notebook_url(user, project_name))
else:
Printer.print_warning(
'This project `{}` does not have a running notebook.'.format(project_name))
click.echo('You can start a notebook with this command: polyaxon notebook start --help') |
def start(ctx, file, u): # pylint:disable=redefined-builtin
"""Start a notebook deployment for this project.
Uses [Caching](/references/polyaxon-cli/#caching)
Example:
\b
```bash
$ polyaxon notebook start -f file -f file_override ...
```
Example: upload before running
\b
```bash
$ polyaxon -p user12/mnist notebook start -f file -u
```
"""
specification = None
job_config = None
if file:
specification = check_polyaxonfile(file, log=False).specification
# Check if we need to upload
if u:
ctx.invoke(upload, sync=False)
if specification:
# pylint:disable=protected-access
check_polyaxonfile_kind(specification=specification, kind=specification._NOTEBOOK)
job_config = specification.parsed_data
user, project_name = get_project_or_local(ctx.obj.get('project'))
try:
response = PolyaxonClient().project.start_notebook(user, project_name, job_config)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not start notebook project `{}`.'.format(project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
if response.status_code == 200:
Printer.print_header("A notebook for this project is already running on:")
click.echo(get_notebook_url(user, project_name))
sys.exit(0)
if response.status_code != 201:
Printer.print_error('Something went wrong, Notebook was not created.')
sys.exit(1)
Printer.print_success('Notebook is being deployed for project `{}`'.format(project_name))
clint.textui.puts("It may take some time before you can access the notebook.\n")
clint.textui.puts("Your notebook will be available on:\n")
with clint.textui.indent(4):
clint.textui.puts(get_notebook_url(user, project_name)) |
def stop(ctx, commit, yes):
"""Stops the notebook deployment for this project if it exists.
Uses [Caching](/references/polyaxon-cli/#caching)
"""
user, project_name = get_project_or_local(ctx.obj.get('project'))
if not yes and not click.confirm("Are sure you want to stop notebook "
"for project `{}/{}`".format(user, project_name)):
click.echo('Existing without stopping notebook.')
sys.exit(1)
if commit is None:
commit = True
try:
PolyaxonClient().project.stop_notebook(user, project_name, commit)
Printer.print_success('Notebook is being deleted')
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not stop notebook project `{}`.'.format(project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1) |
def cli(context, verbose):
""" Polyaxon CLI tool to:
* Parse, Validate, and Check Polyaxonfiles.
* Interact with Polyaxon server.
* Run and Monitor experiments.
Check the help available for each command listed below.
"""
configure_logger(verbose or GlobalConfigManager.get_value('verbose'))
non_check_cmds = ['config', 'version', 'login', 'logout', 'deploy', 'admin', 'teardown']
if context.invoked_subcommand not in non_check_cmds:
check_cli_version() |
def check(self):
"""Add platform specific checks"""
if not self.is_valid:
raise PolyaxonDeploymentConfigError(
'Deployment type `{}` not supported'.format(self.deployment_type))
check = False
if self.is_kubernetes:
check = self.check_for_kubernetes()
elif self.is_docker_compose:
check = self.check_for_docker_compose()
elif self.is_docker:
check = self.check_for_docker()
elif self.is_heroku:
check = self.check_for_heroku()
if not check:
raise PolyaxonDeploymentConfigError(
'Deployment `{}` is not valid'.format(self.deployment_type)) |
def install(self):
"""Install polyaxon using the current config to the correct platform."""
if not self.is_valid:
raise PolyaxonDeploymentConfigError(
'Deployment type `{}` not supported'.format(self.deployment_type))
if self.is_kubernetes:
self.install_on_kubernetes()
elif self.is_docker_compose:
self.install_on_docker_compose()
elif self.is_docker:
self.install_on_docker()
elif self.is_heroku:
self.install_on_heroku() |
def upgrade(self):
"""Upgrade deployment."""
if not self.is_valid:
raise PolyaxonDeploymentConfigError(
'Deployment type `{}` not supported'.format(self.deployment_type))
if self.is_kubernetes:
self.upgrade_on_kubernetes()
elif self.is_docker_compose:
self.upgrade_on_docker_compose()
elif self.is_docker:
self.upgrade_on_docker()
elif self.is_heroku:
self.upgrade_on_heroku() |
def teardown(self, hooks=True):
"""Teardown Polyaxon."""
if not self.is_valid:
raise PolyaxonDeploymentConfigError(
'Deployment type `{}` not supported'.format(self.deployment_type))
if self.is_kubernetes:
self.teardown_on_kubernetes(hooks=hooks)
elif self.is_docker_compose:
self.teardown_on_docker_compose()
elif self.is_docker:
self.teardown_on_docker(hooks=hooks)
elif self.is_heroku:
self.teardown_on_heroku(hooks=hooks) |
def project(ctx, project): # pylint:disable=redefined-outer-name
"""Commands for projects."""
if ctx.invoked_subcommand not in ['create', 'list']:
ctx.obj = ctx.obj or {}
ctx.obj['project'] = project |
def create(ctx, name, description, tags, private, init):
"""Create a new project.
Uses [Caching](/references/polyaxon-cli/#caching)
Example:
\b
```bash
$ polyaxon project create --name=cats-vs-dogs --description="Image Classification with DL"
```
"""
try:
tags = tags.split(',') if tags else None
project_dict = dict(name=name, description=description, is_public=not private, tags=tags)
project_config = ProjectConfig.from_dict(project_dict)
except ValidationError:
Printer.print_error('Project name should contain only alpha numerical, "-", and "_".')
sys.exit(1)
try:
_project = PolyaxonClient().project.create_project(project_config)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not create project `{}`.'.format(name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
Printer.print_success("Project `{}` was created successfully.".format(_project.name))
if init:
ctx.obj = {}
ctx.invoke(init_project, project=name) |
def list(page): # pylint:disable=redefined-builtin
"""List projects.
Uses [Caching](/references/polyaxon-cli/#caching)
"""
user = AuthConfigManager.get_value('username')
if not user:
Printer.print_error('Please login first. `polyaxon login --help`')
page = page or 1
try:
response = PolyaxonClient().project.list_projects(user, page=page)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not get list of projects.')
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
meta = get_meta_response(response)
if meta:
Printer.print_header('Projects for current user')
Printer.print_header('Navigation:')
dict_tabulate(meta)
else:
Printer.print_header('No projects found for current user')
objects = list_dicts_to_tabulate(
[o.to_light_dict(
humanize_values=True,
exclude_attrs=['uuid', 'experiment_groups', 'experiments', 'description',
'num_experiments', 'num_independent_experiments',
'num_experiment_groups', 'num_jobs', 'num_builds', 'unique_name'])
for o in response['results']])
if objects:
Printer.print_header("Projects:")
dict_tabulate(objects, is_list_dict=True) |
def get(ctx):
"""Get info for current project, by project_name, or user/project_name.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
To get current project:
\b
```bash
$ polyaxon project get
```
To get a project by name
\b
```bash
$ polyaxon project get user/project
```
"""
user, project_name = get_project_or_local(ctx.obj.get('project'))
try:
response = PolyaxonClient().project.get_project(user, project_name)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not get project `{}`.'.format(project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
get_project_details(response) |
def delete(ctx):
"""Delete project.
Uses [Caching](/references/polyaxon-cli/#caching)
"""
user, project_name = get_project_or_local(ctx.obj.get('project'))
if not click.confirm("Are sure you want to delete project `{}/{}`".format(user, project_name)):
click.echo('Existing without deleting project.')
sys.exit(1)
try:
response = PolyaxonClient().project.delete_project(user, project_name)
local_project = ProjectManager.get_config()
if local_project and (user, project_name) == (local_project.user, local_project.name):
# Purge caching
ProjectManager.purge()
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not delete project `{}/{}`.'.format(user, project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
if response.status_code == 204:
Printer.print_success("Project `{}/{}` was delete successfully".format(user, project_name)) |
def update(ctx, name, description, tags, private):
"""Update project.
Uses [Caching](/references/polyaxon-cli/#caching)
Example:
\b
```bash
$ polyaxon update foobar --description="Image Classification with DL using TensorFlow"
```
\b
```bash
$ polyaxon update mike1/foobar --description="Image Classification with DL using TensorFlow"
```
\b
```bash
$ polyaxon update --tags="foo, bar"
```
"""
user, project_name = get_project_or_local(ctx.obj.get('project'))
update_dict = {}
if name:
update_dict['name'] = name
if description:
update_dict['description'] = description
if private is not None:
update_dict['is_public'] = not private
tags = validate_tags(tags)
if tags:
update_dict['tags'] = tags
if not update_dict:
Printer.print_warning('No argument was provided to update the project.')
sys.exit(1)
try:
response = PolyaxonClient().project.update_project(user, project_name, update_dict)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not update project `{}`.'.format(project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
Printer.print_success("Project updated.")
get_project_details(response) |
def groups(ctx, query, sort, page):
"""List experiment groups for this project.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
Get all groups:
\b
```bash
$ polyaxon project groups
```
Get all groups with with status {created or running}, and
creation date between 2018-01-01 and 2018-01-02,
and search algorithm not in {grid or random search}
\b
```bash
$ polyaxon project groups \
-q "status:created|running, started_at:2018-01-01..2018-01-02, search_algorithm:~grid|random"
```
Get all groups sorted by update date
\b
```bash
$ polyaxon project groups -s "-updated_at"
```
"""
user, project_name = get_project_or_local(ctx.obj.get('project'))
page = page or 1
try:
response = PolyaxonClient().project.list_experiment_groups(username=user,
project_name=project_name,
query=query,
sort=sort,
page=page)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error(
'Could not get experiment groups for project `{}`.'.format(project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
meta = get_meta_response(response)
if meta:
Printer.print_header('Experiment groups for project `{}/{}`.'.format(user, project_name))
Printer.print_header('Navigation:')
dict_tabulate(meta)
else:
Printer.print_header('No experiment groups found for project `{}/{}`.'.format(
user, project_name))
objects = [Printer.add_status_color(o.to_light_dict(humanize_values=True))
for o in response['results']]
objects = list_dicts_to_tabulate(objects)
if objects:
Printer.print_header("Experiment groups:")
objects.pop('project', None)
objects.pop('user', None)
dict_tabulate(objects, is_list_dict=True) |
def experiments(ctx, metrics, declarations, independent, group, query, sort, page):
"""List experiments for this project.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
Get all experiments:
\b
```bash
$ polyaxon project experiments
```
Get all experiments with with status {created or running}, and
creation date between 2018-01-01 and 2018-01-02, and declarations activation equal to sigmoid
and metric loss less or equal to 0.2
\b
```bash
$ polyaxon project experiments \
-q "status:created|running, started_at:2018-01-01..2018-01-02, \
declarations.activation:sigmoid, metric.loss:<=0.2"
```
Get all experiments sorted by update date
\b
```bash
$ polyaxon project experiments -s "-updated_at"
```
"""
user, project_name = get_project_or_local(ctx.obj.get('project'))
page = page or 1
try:
response = PolyaxonClient().project.list_experiments(username=user,
project_name=project_name,
independent=independent,
group=group,
metrics=metrics,
declarations=declarations,
query=query,
sort=sort,
page=page)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not get experiments for project `{}`.'.format(project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
meta = get_meta_response(response)
if meta:
Printer.print_header('Experiments for project `{}/{}`.'.format(user, project_name))
Printer.print_header('Navigation:')
dict_tabulate(meta)
else:
Printer.print_header('No experiments found for project `{}/{}`.'.format(user, project_name))
if metrics:
objects = get_experiments_with_metrics(response)
elif declarations:
objects = get_experiments_with_declarations(response)
else:
objects = [Printer.add_status_color(o.to_light_dict(humanize_values=True))
for o in response['results']]
objects = list_dicts_to_tabulate(objects)
if objects:
Printer.print_header("Experiments:")
objects.pop('project_name', None)
dict_tabulate(objects, is_list_dict=True) |
def git(ctx, url, private, sync): # pylint:disable=assign-to-new-keyword
"""Set/Sync git repo on this project.
Uses [Caching](/references/polyaxon-cli/#caching)
Example:
\b
```bash
$ polyaxon project git --url=https://github.com/polyaxon/polyaxon-quick-start
```
\b
```bash
$ polyaxon project git --url=https://github.com/polyaxon/polyaxon-quick-start --private
```
"""
user, project_name = get_project_or_local(ctx.obj.get('project'))
def git_set_url():
if private:
click.echo('\nSetting a private git repo "{}" on project: {} ...\n'.format(
url, project_name))
else:
click.echo('\nSetting a public git repo "{}" on project: {} ...\n'.format(
url, project_name))
try:
PolyaxonClient().project.set_repo(user, project_name, url, not private)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not set git repo on project `{}`.'.format(project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
Printer.print_success('Project was successfully initialized with `{}`.'.format(url))
def git_sync_repo():
try:
response = PolyaxonClient().project.sync_repo(user, project_name)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not sync git repo on project `{}`.'.format(project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
click.echo(response.status_code)
Printer.print_success('Project was successfully synced with latest changes.')
if url:
git_set_url()
if sync:
git_sync_repo() |
def ci(ctx, enable, disable): # pylint:disable=assign-to-new-keyword
"""Enable/Disable CI on this project.
Uses [Caching](/references/polyaxon-cli/#caching)
Example:
\b
```bash
$ polyaxon project ci --enable
```
\b
```bash
$ polyaxon project ci --disable
```
"""
user, project_name = get_project_or_local(ctx.obj.get('project'))
def enable_ci():
try:
PolyaxonClient().project.enable_ci(user, project_name)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not enable CI on project `{}`.'.format(project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
Printer.print_success(
'Polyaxon CI was successfully enabled on project: `{}`.'.format(project_name))
def disable_ci():
try:
PolyaxonClient().project.disable_ci(user, project_name)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not disable CI on project `{}`.'.format(project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
Printer.print_success(
'Polyaxon CI was successfully disabled on project: `{}`.'.format(project_name))
if enable:
enable_ci()
if disable:
disable_ci() |
def download(ctx):
"""Download code of the current project."""
user, project_name = get_project_or_local(ctx.obj.get('project'))
try:
PolyaxonClient().project.download_repo(user, project_name)
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not download code for project `{}`.'.format(project_name))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
Printer.print_success('Files downloaded.') |
def write(self,file,optstring="",quote=False):
"""write the 'object' line; additional args are packed in string"""
classid = str(self.id)
if quote: classid = '"'+classid+'"'
# Only use a *single* space between tokens; both chimera's and pymol's DX parser
# does not properly implement the OpenDX specs and produces garbage with multiple
# spaces. (Chimera 1.4.1, PyMOL 1.3)
file.write('object '+classid+' class '+str(self.name)+' '+\
optstring+'\n') |
def edges(self):
"""Edges of the grid cells, origin at centre of 0,0,..,0 grid cell.
Only works for regular, orthonormal grids.
"""
return [self.delta[d,d] * numpy.arange(self.shape[d]+1) + self.origin[d]\
- 0.5*self.delta[d,d] for d in range(self.rank)] |
def write(self, file):
"""Write the *class array* section.
Parameters
----------
file : file
Raises
------
ValueError
If the `dxtype` is not a valid type, :exc:`ValueError` is
raised.
"""
if self.type not in self.dx_types:
raise ValueError(("DX type {} is not supported in the DX format. \n"
"Supported valus are: {}\n"
"Use the type=<type> keyword argument.").format(
self.type, list(self.dx_types.keys())))
typelabel = (self.typequote+self.type+self.typequote)
DXclass.write(self,file,
'type {0} rank 0 items {1} data follows'.format(
typelabel, self.array.size))
# grid data, serialized as a C array (z fastest varying)
# (flat iterator is equivalent to: for x: for y: for z: grid[x,y,z])
# VMD's DX reader requires exactly 3 values per line
fmt_string = "{:d}"
if (self.array.dtype.kind == 'f' or self.array.dtype.kind == 'c'):
precision = numpy.finfo(self.array.dtype).precision
fmt_string = "{:."+"{:d}".format(precision)+"f}"
values_per_line = 3
values = self.array.flat
while 1:
try:
for i in range(values_per_line):
file.write(fmt_string.format(next(values)) + "\t")
file.write('\n')
except StopIteration:
file.write('\n')
break
file.write('attribute "dep" string "positions"\n') |
def write(self, filename):
"""Write the complete dx object to the file.
This is the simple OpenDX format which includes the data into
the header via the 'object array ... data follows' statement.
Only simple regular arrays are supported.
The format should be compatible with VMD's dx reader plugin.
"""
# comments (VMD chokes on lines of len > 80, so truncate)
maxcol = 80
with open(filename,'w') as outfile:
for line in self.comments:
comment = '# '+str(line)
outfile.write(comment[:maxcol]+'\n')
# each individual object
for component,object in self.sorted_components():
object.write(outfile)
# the field object itself
DXclass.write(self,outfile,quote=True)
for component,object in self.sorted_components():
outfile.write('component "%s" value %s\n' % (component,str(object.id))) |
def read(self,file):
"""Read DX field from file.
dx = OpenDX.field.read(dxfile)
The classid is discarded and replaced with the one from the file.
"""
DXfield = self
p = DXParser(file)
p.parse(DXfield) |
def sorted_components(self):
"""iterator that returns (component,object) in id order"""
for component, object in \
sorted(self.components.items(),
key=lambda comp_obj: comp_obj[1].id):
yield component, object |
def histogramdd(self):
"""Return array data as (edges,grid), i.e. a numpy nD histogram."""
shape = self.components['positions'].shape
edges = self.components['positions'].edges()
hist = self.components['data'].array.reshape(shape)
return (hist,edges) |
def value(self,ascode=None):
"""Return text cast to the correct type or the selected type"""
if ascode is None:
ascode = self.code
return self.cast[ascode](self.text) |
def initialize(self):
"""Initialize the corresponding DXclass from the data.
class = DXInitObject.initialize()
"""
return self.DXclasses[self.type](self.id,**self.args) |
def parse(self,DXfield):
"""Parse the dx file and construct a DX field object with component classes.
A :class:`field` instance *DXfield* must be provided to be
filled by the parser::
DXfield_object = OpenDX.field(*args)
parse(DXfield_object)
A tokenizer turns the dx file into a stream of tokens. A
hierarchy of parsers examines the stream. The level-0 parser
('general') distinguishes comments and objects (level-1). The
object parser calls level-3 parsers depending on the object
found. The basic idea is that of a 'state machine'. There is
one parser active at any time. The main loop is the general
parser.
* Constructing the dx objects with classtype and classid is
not implemented yet.
* Unknown tokens raise an exception.
"""
self.DXfield = DXfield # OpenDX.field (used by comment parser)
self.currentobject = None # containers for data
self.objects = [] # |
self.tokens = [] # token buffer
with open(self.filename,'r') as self.dxfile:
self.use_parser('general') # parse the whole file and populate self.objects
# assemble field from objects
for o in self.objects:
if o.type == 'field':
# Almost ignore the field object; VMD, for instance,
# does not write components. To make this work
# seamlessly I have to think harder how to organize
# and use the data, eg preping the field object
# properly and the initializing. Probably should also
# check uniqueness of ids etc.
DXfield.id = o.id
continue
c = o.initialize()
self.DXfield.add(c.component,c)
# free space
del self.currentobject, self.objects |
def __general(self):
"""Level-0 parser and main loop.
Look for a token that matches a level-1 parser and hand over control."""
while 1: # main loop
try:
tok = self.__peek() # only peek, apply_parser() will consume
except DXParserNoTokens:
# save previous DXInitObject
# (kludge in here as the last level-2 parser usually does not return
# via the object parser)
if self.currentobject and self.currentobject not in self.objects:
self.objects.append(self.currentobject)
return # stop parsing and finish
# decision branches for all level-1 parsers:
# (the only way to get out of the lower level parsers!)
if tok.iscode('COMMENT'):
self.set_parser('comment') # switch the state
elif tok.iscode('WORD') and tok.equals('object'):
self.set_parser('object') # switch the state
elif self.__parser is self.__general:
# Either a level-2 parser screwed up or some level-1
# construct is not implemented. (Note: this elif can
# be only reached at the beginning or after comments;
# later we never formally switch back to __general
# (would create inifinite loop)
raise DXParseError('Unknown level-1 construct at '+str(tok))
self.apply_parser() |
def __comment(self):
"""Level-1 parser for comments.
pattern: #.*
Append comment (with initial '# ' stripped) to all comments.
"""
tok = self.__consume()
self.DXfield.add_comment(tok.value())
self.set_parser('general') |
def __object(self):
"""Level-1 parser for objects.
pattern: 'object' id 'class' type ...
id ::= integer|string|'"'white space string'"'
type ::= string
"""
self.__consume() # 'object'
classid = self.__consume().text
word = self.__consume().text
if word != "class":
raise DXParseError("reserved word %s should have been 'class'." % word)
# save previous DXInitObject
if self.currentobject:
self.objects.append(self.currentobject)
# setup new DXInitObject
classtype = self.__consume().text
self.currentobject = DXInitObject(classtype=classtype,classid=classid)
self.use_parser(classtype) |
def __gridpositions(self):
"""Level-2 parser for gridpositions.
pattern:
object 1 class gridpositions counts 97 93 99
origin -46.5 -45.5 -48.5
delta 1 0 0
delta 0 1 0
delta 0 0 1
"""
try:
tok = self.__consume()
except DXParserNoTokens:
return
if tok.equals('counts'):
shape = []
try:
while True:
# raises exception if not an int
self.__peek().value('INTEGER')
tok = self.__consume()
shape.append(tok.value('INTEGER'))
except (DXParserNoTokens, ValueError):
pass
if len(shape) == 0:
raise DXParseError('gridpositions: no shape parameters')
self.currentobject['shape'] = shape
elif tok.equals('origin'):
origin = []
try:
while (self.__peek().iscode('INTEGER') or
self.__peek().iscode('REAL')):
tok = self.__consume()
origin.append(tok.value())
except DXParserNoTokens:
pass
if len(origin) == 0:
raise DXParseError('gridpositions: no origin parameters')
self.currentobject['origin'] = origin
elif tok.equals('delta'):
d = []
try:
while (self.__peek().iscode('INTEGER') or
self.__peek().iscode('REAL')):
tok = self.__consume()
d.append(tok.value())
except DXParserNoTokens:
pass
if len(d) == 0:
raise DXParseError('gridpositions: missing delta parameters')
try:
self.currentobject['delta'].append(d)
except KeyError:
self.currentobject['delta'] = [d]
else:
raise DXParseError('gridpositions: '+str(tok)+' not recognized.') |
def __gridconnections(self):
"""Level-2 parser for gridconnections.
pattern:
object 2 class gridconnections counts 97 93 99
"""
try:
tok = self.__consume()
except DXParserNoTokens:
return
if tok.equals('counts'):
shape = []
try:
while True:
# raises exception if not an int
self.__peek().value('INTEGER')
tok = self.__consume()
shape.append(tok.value('INTEGER'))
except (DXParserNoTokens, ValueError):
pass
if len(shape) == 0:
raise DXParseError('gridconnections: no shape parameters')
self.currentobject['shape'] = shape
else:
raise DXParseError('gridconnections: '+str(tok)+' not recognized.') |
def __array(self):
"""Level-2 parser for arrays.
pattern:
object 3 class array type double rank 0 items 12 data follows
0 2 0
0 0 3.6
0 -2.0 1e-12
+4.534e+01 .34534 0.43654
attribute "dep" string "positions"
"""
try:
tok = self.__consume()
except DXParserNoTokens:
return
if tok.equals('type'):
tok = self.__consume()
if not tok.iscode('STRING'):
raise DXParseError('array: type was "%s", not a string.'%\
tok.text)
self.currentobject['type'] = tok.value()
elif tok.equals('rank'):
tok = self.__consume()
try:
self.currentobject['rank'] = tok.value('INTEGER')
except ValueError:
raise DXParseError('array: rank was "%s", not an integer.'%\
tok.text)
elif tok.equals('items'):
tok = self.__consume()
try:
self.currentobject['size'] = tok.value('INTEGER')
except ValueError:
raise DXParseError('array: items was "%s", not an integer.'%\
tok.text)
elif tok.equals('data'):
tok = self.__consume()
if not tok.iscode('STRING'):
raise DXParseError('array: data was "%s", not a string.'%\
tok.text)
if tok.text != 'follows':
raise NotImplementedError(\
'array: Only the "data follows header" format is supported.')
if not self.currentobject['size']:
raise DXParseError("array: missing number of items")
# This is the slow part. Once we get here, we are just
# reading in a long list of numbers. Conversion to floats
# will be done later when the numpy array is created.
# Don't assume anything about whitespace or the number of elements per row
self.currentobject['array'] = []
while len(self.currentobject['array']) <self.currentobject['size']:
self.currentobject['array'].extend(self.dxfile.readline().strip().split())
# If you assume that there are three elements per row
# (except the last) the following version works and is a little faster.
# for i in range(int(numpy.ceil(self.currentobject['size']/3))):
# self.currentobject['array'].append(self.dxfile.readline())
# self.currentobject['array'] = ' '.join(self.currentobject['array']).split()
elif tok.equals('attribute'):
# not used at the moment
attribute = self.__consume().value()
if not self.__consume().equals('string'):
raise DXParseError('array: "string" expected.')
value = self.__consume().value()
else:
raise DXParseError('array: '+str(tok)+' not recognized.') |
def __field(self):
"""Level-2 parser for a DX field object.
pattern:
object "site map 1" class field
component "positions" value 1
component "connections" value 2
component "data" value 3
"""
try:
tok = self.__consume()
except DXParserNoTokens:
return
if tok.equals('component'):
component = self.__consume().value()
if not self.__consume().equals('value'):
raise DXParseError('field: "value" expected')
classid = self.__consume().value()
try:
self.currentobject['components'][component] = classid
except KeyError:
self.currentobject['components'] = {component:classid}
else:
raise DXParseError('field: '+str(tok)+' not recognized.') |
def use_parser(self,parsername):
"""Set parsername as the current parser and apply it."""
self.__parser = self.parsers[parsername]
self.__parser() |
def __tokenize(self,string):
"""Split s into tokens and update the token buffer.
__tokenize(string)
New tokens are appended to the token buffer, discarding white
space. Based on http://effbot.org/zone/xml-scanner.htm
"""
for m in self.dx_regex.finditer(string.strip()):
code = m.lastgroup
text = m.group(m.lastgroup)
tok = Token(code,text)
if not tok.iscode('WHITESPACE'):
self.tokens.append(tok) |
def __refill_tokenbuffer(self):
"""Add a new tokenized line from the file to the token buffer.
__refill_tokenbuffer()
Only reads a new line if the buffer is empty. It is safe to
call it repeatedly.
At end of file, method returns empty strings and it is up to
__peek and __consume to flag the end of the stream.
"""
if len(self.tokens) == 0:
self.__tokenize(self.dxfile.readline()) |
def read(self, filename):
"""Populate the instance from the plt file *filename*."""
from struct import calcsize, unpack
if not filename is None:
self.filename = filename
with open(self.filename, 'rb') as plt:
h = self.header = self._read_header(plt)
nentries = h['nx'] * h['ny'] * h['nz']
# quick and dirty... slurp it all in one go
datafmt = h['bsaflag']+str(nentries)+self._data_bintype
a = numpy.array(unpack(datafmt, plt.read(calcsize(datafmt))))
self.header['filename'] = self.filename
self.array = a.reshape(h['nz'], h['ny'], h['nx']).transpose() # unpack plt in reverse!!
self.delta = self._delta()
self.origin = numpy.array([h['xmin'], h['ymin'], h['zmin']]) + 0.5*numpy.diagonal(self.delta)
self.rank = h['rank'] |
def _read_header(self, pltfile):
"""Read header bytes, try all possibilities for byte order/size/alignment."""
nheader = struct.calcsize(self._headerfmt)
names = [r.key for r in self._header_struct]
binheader = pltfile.read(nheader)
def decode_header(bsaflag='@'):
h = dict(zip(names, struct.unpack(bsaflag+self._headerfmt, binheader)))
h['bsaflag'] = bsaflag
return h
for flag in '@=<>':
# try all endinaness and alignment options until we find something that looks sensible
header = decode_header(flag)
if header['rank'] == 3:
break # only legal value according to spec
header = None
if header is None:
raise TypeError("Cannot decode header --- corrupted or wrong format?")
for rec in self._header_struct:
if not rec.is_legal_dict(header):
warnings.warn("Key %s: Illegal value %r" % (rec.key, header[rec.key]))
return header |
def ndmeshgrid(*arrs):
"""Return a mesh grid for N dimensions.
The input are N arrays, each of which contains the values along one axis of
the coordinate system. The arrays do not have to have the same number of
entries. The function returns arrays that can be fed into numpy functions
so that they produce values for *all* points spanned by the axes *arrs*.
Original from
http://stackoverflow.com/questions/1827489/numpy-meshgrid-in-3d and fixed.
.. SeeAlso: :func:`numpy.meshgrid` for the 2D case.
"""
#arrs = tuple(reversed(arrs)) <-- wrong on stackoverflow.com
arrs = tuple(arrs)
lens = list(map(len, arrs))
dim = len(arrs)
sz = 1
for s in lens:
sz *= s
ans = []
for i, arr in enumerate(arrs):
slc = [1] * dim
slc[i] = lens[i]
arr2 = numpy.asanyarray(arr).reshape(slc)
for j, sz in enumerate(lens):
if j != i:
arr2 = arr2.repeat(sz, axis=j)
ans.append(arr2)
return tuple(ans) |
def resample(self, edges):
"""Resample data to a new grid with edges *edges*.
This method creates a new grid with the data from the current
grid resampled to a regular grid specified by *edges*. The
order of the interpolation is set by
:attr:`Grid.interpolation_spline_order`: change the value
*before* calling :meth:`resample`.
Parameters
----------
edges : tuple of arrays or Grid
edges of the new grid or a :class:`Grid` instance that
provides :attr:`Grid.edges`
Returns
-------
Grid
a new :class:`Grid` with the data interpolated over the
new grid cells
Examples
--------
Providing *edges* (a tuple of three arrays, indicating the
boundaries of each grid cell)::
g = grid.resample(edges)
As a convenience, one can also supply another :class:`Grid` as
the argument for this method ::
g = grid.resample(othergrid)
and the edges are taken from :attr:`Grid.edges`.
"""
try:
edges = edges.edges # can also supply another Grid
except AttributeError:
pass
midpoints = self._midpoints(edges)
coordinates = ndmeshgrid(*midpoints)
# feed a meshgrid to generate all points
newgrid = self.interpolated(*coordinates)
return self.__class__(newgrid, edges) |
def resample_factor(self, factor):
"""Resample to a new regular grid.
Parameters
----------
factor : float
The number of grid cells are scaled with `factor` in each
dimension, i.e., ``factor * N_i`` cells along each
dimension i.
Returns
-------
Grid
See Also
--------
resample
"""
# new number of edges N' = (N-1)*f + 1
newlengths = [(N - 1) * float(factor) + 1 for N in self._len_edges()]
edges = [numpy.linspace(start, stop, num=int(N), endpoint=True)
for (start, stop, N) in
zip(self._min_edges(), self._max_edges(), newlengths)]
return self.resample(edges) |
def _update(self):
"""compute/update all derived data
Can be called without harm and is idem-potent.
Updates these attributes and methods:
:attr:`origin`
the center of the cell with index 0,0,0
:attr:`midpoints`
centre coordinate of each grid cell
:meth:`interpolated`
spline interpolation function that can generated a value for
coordinate
"""
self.delta = numpy.array(list(
map(lambda e: (e[-1] - e[0]) / (len(e) - 1), self.edges)))
self.midpoints = self._midpoints(self.edges)
self.origin = numpy.array(list(map(lambda m: m[0], self.midpoints)))
if self.__interpolated is not None:
# only update if we are using it
self.__interpolated = self._interpolationFunctionFactory() |
def interpolated(self):
"""B-spline function over the data grid(x,y,z).
The :func:`interpolated` function allows one to obtain data
values for any values of the coordinates::
interpolated([x1,x2,...],[y1,y2,...],[z1,z2,...]) -> F[x1,y1,z1],F[x2,y2,z2],...
The interpolation order is set in
:attr:`Grid.interpolation_spline_order`.
The interpolated function is computed once and is cached for better
performance. Whenever :attr:`~Grid.interpolation_spline_order` is
modified, :meth:`Grid.interpolated` is recomputed.
The value for unknown data is set in :attr:`Grid.interpolation_cval`
(TODO: also recompute when ``interpolation_cval`` value is changed.)
Example
-------
Example usage for resampling::
XX, YY, ZZ = numpy.mgrid[40:75:0.5, 96:150:0.5, 20:50:0.5]
FF = interpolated(XX, YY, ZZ)
Note
----
Values are interpolated with a spline function. It is possible
that the spline will generate values that would not normally
appear in the data. For example, a density is non-negative but
a cubic spline interpolation can generate negative values,
especially at the boundary between 0 and high values.
"""
if self.__interpolated is None:
self.__interpolated = self._interpolationFunctionFactory()
return self.__interpolated |
def load(self, filename, file_format=None):
"""Load saved (pickled or dx) grid and edges from <filename>.pickle
Grid.load(<filename>.pickle)
Grid.load(<filename>.dx)
The load() method calls the class's constructor method and
completely resets all values, based on the loaded data.
"""
loader = self._get_loader(filename, file_format=file_format)
loader(filename) |
def _load_cpp4(self, filename):
"""Initializes Grid from a CCP4 file."""
ccp4 = CCP4.CCP4()
ccp4.read(filename)
grid, edges = ccp4.histogramdd()
self.__init__(grid=grid, edges=edges, metadata=self.metadata) |
def _load_dx(self, filename):
"""Initializes Grid from a OpenDX file."""
dx = OpenDX.field(0)
dx.read(filename)
grid, edges = dx.histogramdd()
self.__init__(grid=grid, edges=edges, metadata=self.metadata) |
def _load_plt(self, filename):
"""Initialize Grid from gOpenMol plt file."""
g = gOpenMol.Plt()
g.read(filename)
grid, edges = g.histogramdd()
self.__init__(grid=grid, edges=edges, metadata=self.metadata) |
def export(self, filename, file_format=None, type=None, typequote='"'):
"""export density to file using the given format.
The format can also be deduced from the suffix of the filename
though the *format* keyword takes precedence.
The default format for export() is 'dx'. Use 'dx' for
visualization.
Implemented formats:
dx
:mod:`OpenDX`
pickle
pickle (use :meth:`Grid.load` to restore); :meth:`Grid.save`
is simpler than ``export(format='python')``.
Parameters
----------
filename : str
name of the output file
file_format : {'dx', 'pickle', None} (optional)
output file format, the default is "dx"
type : str (optional)
for DX, set the output DX array type, e.g., "double" or "float".
By default (``None``), the DX type is determined from the numpy
dtype of the array of the grid (and this will typically result in
"double").
.. versionadded:: 0.4.0
typequote : str (optional)
For DX, set the character used to quote the type string;
by default this is a double-quote character, '"'.
Custom parsers like the one from NAMD-GridForces (backend for MDFF)
expect no quotes, and typequote='' may be used to appease them.
.. versionadded:: 0.5.0
"""
exporter = self._get_exporter(filename, file_format=file_format)
exporter(filename, type=type, typequote=typequote) |
def _export_python(self, filename, **kwargs):
"""Pickle the Grid object
The object is dumped as a dictionary with grid and edges: This
is sufficient to recreate the grid object with __init__().
"""
data = dict(grid=self.grid, edges=self.edges, metadata=self.metadata)
with open(filename, 'wb') as f:
cPickle.dump(data, f, cPickle.HIGHEST_PROTOCOL) |
def _export_dx(self, filename, type=None, typequote='"', **kwargs):
"""Export the density grid to an OpenDX file.
The file format is the simplest regular grid array and it is
also understood by VMD's and Chimera's DX reader; PyMOL
requires the dx `type` to be set to "double".
For the file format see
http://opendx.sdsc.edu/docs/html/pages/usrgu068.htm#HDREDF
"""
root, ext = os.path.splitext(filename)
filename = root + '.dx'
comments = [
'OpenDX density file written by gridDataFormats.Grid.export()',
'File format: http://opendx.sdsc.edu/docs/html/pages/usrgu068.htm#HDREDF',
'Data are embedded in the header and tied to the grid positions.',
'Data is written in C array order: In grid[x,y,z] the axis z is fastest',
'varying, then y, then finally x, i.e. z is the innermost loop.'
]
# write metadata in comments section
if self.metadata:
comments.append('Meta data stored with the python Grid object:')
for k in self.metadata:
comments.append(' ' + str(k) + ' = ' + str(self.metadata[k]))
comments.append(
'(Note: the VMD dx-reader chokes on comments below this line)')
components = dict(
positions=OpenDX.gridpositions(1, self.grid.shape, self.origin,
self.delta),
connections=OpenDX.gridconnections(2, self.grid.shape),
data=OpenDX.array(3, self.grid, type=type, typequote=typequote),
)
dx = OpenDX.field('density', components=components, comments=comments)
dx.write(filename) |
def centers(self):
"""Returns the coordinates of the centers of all grid cells as an
iterator."""
for idx in numpy.ndindex(self.grid.shape):
yield self.delta * numpy.array(idx) + self.origin |
def check_compatible(self, other):
"""Check if *other* can be used in an arithmetic operation.
1) *other* is a scalar
2) *other* is a grid defined on the same edges
:Raises: :exc:`TypeError` if not compatible.
"""
if not (numpy.isreal(other) or self == other):
raise TypeError(
"The argument can not be arithmetically combined with the grid. "
"It must be a scalar or a grid with identical edges. "
"Use Grid.resample(other.edges) to make a new grid that is "
"compatible with other.")
return True |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.