def test_update_project(self):
object = ExperimentConfig(faker.word())
experiment_uuid = uuid.uuid4().hex
httpretty.register_uri(httpretty.PATCH,
ExperimentClient._build_url(
self.client.base_url,
ExperimentClient.ENDPOINT, experiment_uuid),
body=json.dumps(object.to_dict()),
content_type='application/json',
status=200)
result = self.client.update_experiment(experiment_uuid,
{'name': 'new'})
assert result.to_dict() == object.to_dict()
def test_stop_experiment(self):
object = ExperimentConfig(name=faker.word())
experiment_uuid = uuid.uuid4().hex
httpretty.register_uri(httpretty.POST,
ExperimentClient._build_url(
self.client.base_url,
ExperimentClient.ENDPOINT, experiment_uuid,
'stop'),
body=json.dumps(object.to_dict()),
content_type='application/json',
status=200)
result = self.client.stop(experiment_uuid)
assert result.to_dict() == object.to_dict()
def test_create_experiment(self):
project_uuid = uuid.uuid4().hex
object = ExperimentConfig(name=faker.word(), project=project_uuid)
httpretty.register_uri(httpretty.POST,
ProjectClient._build_url(
self.client.base_url,
ProjectClient.ENDPOINT, project_uuid,
'experiments'),
body=json.dumps(object.to_dict()),
content_type='application/json',
status=200)
result = self.client.create_experiment(project_uuid, object)
assert result.to_dict() == object.to_dict()
def test_update_project(self):
object = ExperimentConfig(config={})
httpretty.register_uri(httpretty.PATCH,
ExperimentClient._build_url(
self.client.base_url,
ExperimentClient.ENDPOINT, 'username',
'project_name', 'experiments', 1),
body=json.dumps(object.to_dict()),
content_type='application/json',
status=200)
result = self.client.update_experiment('username', 'project_name', 1,
{'name': 'new'})
assert result.to_dict() == object.to_dict()
def test_project_experiments_and_groups_config(self):
uuid_value = uuid.uuid4().hex
config_dict = {
'name':
'test',
'description':
'',
'is_public':
True,
'experiment_groups': [
ExperimentGroupConfig(content='content',
uuid=uuid_value,
project=uuid_value).to_dict()
],
'experiments': [
ExperimentConfig(config={},
uuid=uuid_value,
project=uuid_value).to_dict()
]
}
config = ProjectConfig.from_dict(config_dict)
assert_equal_dict(config_dict, config.to_dict())
config_dict.pop('description')
config_dict.pop('experiment_groups')
config_dict.pop('experiments')
assert_equal_dict(config_dict, config.to_light_dict())
def test_experiment_with_jobs_config(self):
config_dict = {
'sequence':
2,
'config': {},
'content':
'',
'uuid':
uuid.uuid4().hex,
'project':
uuid.uuid4().hex,
'group':
uuid.uuid4().hex,
'last_status':
'Running',
'num_jobs':
1,
'jobs': [
ExperimentJobConfig(uuid.uuid4().hex,
uuid.uuid4().hex,
datetime.now(),
definition={}).to_dict()
]
}
config = ExperimentConfig.from_dict(config_dict)
assert config.to_dict() == config_dict
def test_experiment_config(self):
config_dict = {
'name': 'test',
'uuid': uuid.uuid4().hex,
'project': uuid.uuid4().hex
}
config = ExperimentConfig.from_dict(config_dict)
assert config.to_dict() == config_dict
def run(ctx, file, description, u): # pylint:disable=redefined-builtin
"""Run polyaxonfile specification.
Example:
\b
```bash
$ polyaxon run -f file -f file_override ...
```
Example: upload before running
\b
```bash
$ polyaxon run -f file -u
```
"""
file = file or 'polyaxonfile.yml'
specification = check_polyaxonfile(file, log=False).specification
# Check if we need to upload
if u:
ctx.invoke(upload, async=False)
project = ProjectManager.get_config_or_raise()
project_client = PolyaxonClients().project
if specification.is_experiment:
click.echo('Creating an independent experiment.')
experiment = ExperimentConfig(
description=description,
config=specification.parsed_data)
try:
project_client.create_experiment(project.user,
project.name,
experiment)
except (PolyaxonHTTPError, PolyaxonShouldExitError) as e:
Printer.print_error('Could not create experiment.')
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
Printer.print_success('Experiment was created')
else:
click.echo('Creating an experiment group with the following definition:')
experiments_def = specification.experiments_def
get_group_experiments_info(**experiments_def)
experiment_group = ExperimentGroupConfig(
description=description,
content=specification._data) # pylint:disable=protected-access
try:
project_client.create_experiment_group(project.user,
project.name,
experiment_group)
Printer.print_success('Experiment group was created')
except (PolyaxonHTTPError, PolyaxonShouldExitError) as e:
Printer.print_error('Could not create experiment group.')
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
def test_experiment_with_jobs_config(self):
config_dict = {
'sequence':
2,
'config': {},
'content':
'',
'unique_name':
'adam.proj.1',
'uuid':
uuid.uuid4().hex,
'project':
uuid.uuid4().hex,
'project_name':
'user.name',
'experiment_group':
uuid.uuid4().hex,
'experiment_group_name':
'user.name.1',
'last_status':
'Running',
'num_jobs':
1,
'created_at':
local_now().isoformat(),
'updated_at':
local_now().isoformat(),
'started_at':
local_now().isoformat(),
'finished_at':
local_now().isoformat(),
'jobs': [
ExperimentJobConfig(uuid=uuid.uuid4().hex,
experiment=uuid.uuid4().hex,
experiment_name='name.name.1',
created_at=local_now(),
updated_at=local_now(),
definition={}).to_dict()
]
}
config = ExperimentConfig.from_dict(config_dict)
config_to_dict = config.to_dict()
assert config_to_dict.pop('total_run') == '0s'
config_to_dict.pop('declarations')
config_to_dict.pop('description')
config_to_dict.pop('is_clone')
config_to_dict.pop('is_done')
config_to_dict.pop('is_running')
config_to_dict.pop('last_metric')
config_to_dict.pop('resources')
config_to_dict.pop('user')
assert config_to_dict == config_dict
config_to_dict = config.to_light_dict(humanize_values=True)
assert config_to_dict.pop('total_run') == '0s'
assert config_to_dict.pop('created_at') == 'a few seconds ago'
assert config_to_dict.pop('started_at') == 'a few seconds ago'
assert config_to_dict.pop('finished_at') == 'a few seconds ago'
def update_experiment(self, experiment_uuid, patch_dict):
request_url = self._build_url(self._get_http_url(), experiment_uuid)
try:
response = self.patch(request_url, json=patch_dict)
return ExperimentConfig.from_dict(response.json())
except PolyaxonException as e:
self.handle_exception(
e=e, log_message='Error while updating experiment')
return None
def create_experiment(self, username, project_name, experiment_config):
request_url = self._build_url(self._get_http_url(), username, project_name, 'experiments')
try:
response = self.post(request_url, json=experiment_config.to_dict())
return ExperimentConfig.from_dict(response.json())
except PolyaxonException as e:
self.handle_exception(e=e, log_message='Error while creating experiment group')
return None
def get_experiment(self, experiment_uuid):
request_url = self._build_url(self._get_http_url(), experiment_uuid)
try:
response = self.get(request_url)
return ExperimentConfig.from_dict(response.json())
except PolyaxonException as e:
self.handle_exception(
e=e, log_message='Error while retrieving experiment')
return None
def test_experiment_config(self):
config_dict = {
'uuid': uuid.uuid4().hex,
'project': uuid.uuid4().hex,
'group': uuid.uuid4().hex,
'last_status': 'Running',
'num_jobs': 1,
}
config = ExperimentConfig.from_dict(config_dict)
assert config.to_dict() == config_dict
def test_experiment_config(self):
config_dict = {
'uuid': uuid.uuid4().hex,
'project': uuid.uuid4().hex,
'project_name': 'name.name',
'experiment_group': uuid.uuid4().hex,
'experiment_group_name': 'name.name.1',
'unique_name': 'user.proj.1',
'last_status': 'Running',
'description': 'description',
'content': 'content',
'config': {
'k': 'v'
},
'num_jobs': 1,
'created_at': local_now().isoformat(),
'updated_at': local_now().isoformat(),
}
config = ExperimentConfig.from_dict(config_dict)
config_to_dict = config.to_dict()
config_to_dict.pop('declarations')
config_to_dict.pop('finished_at')
config_to_dict.pop('is_clone')
config_to_dict.pop('is_done')
config_to_dict.pop('is_running')
config_to_dict.pop('jobs')
config_to_dict.pop('last_metric')
config_to_dict.pop('resources')
config_to_dict.pop('sequence')
config_to_dict.pop('started_at')
config_to_dict.pop('total_run')
config_to_dict.pop('user')
assert config_to_dict == config_dict
config_to_dict = config.to_light_dict()
config_dict.pop('uuid')
config_dict.pop('description')
config_dict.pop('content')
config_dict.pop('config')
config_dict.pop('project')
config_dict.pop('experiment_group')
config_dict.pop('updated_at')
config_dict.pop('project_name')
config_to_dict.pop('finished_at')
config_to_dict.pop('is_done')
config_to_dict.pop('is_running')
config_to_dict.pop('sequence')
config_to_dict.pop('started_at')
config_to_dict.pop('total_run')
config_to_dict.pop('user')
assert config_to_dict == config_dict
config_to_dict = config.to_light_dict(humanize_values=True)
assert config_to_dict.pop('created_at') == 'a few seconds ago'
assert config_to_dict.pop('started_at') is None
def test_experiment_group_config(self):
uuid_value = uuid.uuid4().hex
config_dict = {
'sequence':
1,
'content':
'some content',
'uuid':
uuid_value,
'project':
uuid_value,
'project_name':
'user.name',
'num_experiments':
0,
'created_at':
local_now().isoformat(),
'updated_at':
local_now().isoformat(),
'experiments': [
ExperimentConfig(config={},
uuid=uuid_value,
experiment_group=uuid_value,
project=uuid_value).to_dict()
]
}
config = ExperimentGroupConfig.from_dict(config_dict)
config_to_dict = config.to_dict()
config_to_dict.pop('concurrency', None)
config_to_dict.pop('description', None)
config_to_dict.pop('num_failed_experiments', None)
config_to_dict.pop('num_pending_experiments', None)
config_to_dict.pop('num_running_experiments', None)
config_to_dict.pop('num_scheduled_experiments', None)
config_to_dict.pop('num_stopped_experiments', None)
config_to_dict.pop('num_succeeded_experiments', None)
config_to_dict.pop('unique_name', None)
config_to_dict.pop('user', None)
assert config_to_dict == config_dict
config_dict.pop('content')
config_dict.pop('uuid')
config_dict.pop('project')
config_dict.pop('updated_at')
config_dict.pop('sequence')
config_dict.pop('experiments')
config_dict.pop('project_name')
assert_equal_dict(config_dict, config.to_light_dict())
config_to_dict = config.to_dict(humanize_values=True)
assert config_to_dict.pop('created_at') == 'a few seconds ago'
assert config_to_dict.pop('updated_at') == 'a few seconds ago'
config_to_dict = config.to_light_dict(humanize_values=True)
assert config_to_dict.pop('created_at') == 'a few seconds ago'
def test_get_experiment(self):
object = ExperimentConfig(faker.word()).to_dict()
httpretty.register_uri(httpretty.GET,
ExperimentClient._build_url(
self.client.base_url,
ExperimentClient.ENDPOINT, 'uuid'),
body=json.dumps(object),
content_type='application/json',
status=200)
result = self.client.get_experiment('uuid')
assert object == result.to_dict()
def restart(self, experiment_uuid):
"""Restart an experiment."""
request_url = self._build_url(self._get_http_url(), experiment_uuid,
'restart')
try:
response = self.post(request_url)
return ExperimentConfig.from_dict(response.json())
except PolyaxonException as e:
self.handle_exception(
e=e, log_message='Error while restarting experiment')
return None
def test_get_experiment(self):
object = ExperimentConfig(config={}).to_dict()
httpretty.register_uri(httpretty.GET,
ExperimentClient._build_url(
self.client.base_url,
ExperimentClient.ENDPOINT, 'username',
'project_name', 'experiments', 1),
body=json.dumps(object),
content_type='application/json',
status=200)
result = self.client.get_experiment('username', 'project_name', 1)
assert object == result.to_dict()
def test_experiment_group_config(self):
uuid_value = uuid.uuid4().hex
config_dict = {'sequence': 1,
'content': 'some content',
'uuid': uuid_value,
'project': uuid_value,
'num_experiments': 0,
'experiments': [
ExperimentConfig(config={},
uuid=uuid_value,
group=uuid_value,
project=uuid_value).to_dict()]}
config = ExperimentGroupConfig.from_dict(config_dict)
assert config.to_dict() == config_dict
def list_experiments(self, page=1):
"""This gets all experiments visible to the user from the server."""
try:
response = self.get(self._get_http_url(),
params=self.get_page(page=page))
experiments_dict = response.json()
return [
ExperimentConfig.from_dict(experiment)
for experiment in experiments_dict.get("results", [])
]
except PolyaxonException as e:
self.handle_exception(
e=e, log_message='Error while retrieving experiments')
return []
def list_experiments(self, project_uuid, page=1):
"""Fetch list of experiments related to this project."""
request_url = self._build_url(self._get_http_url(), project_uuid,
'experiments')
try:
response = self.get(request_url, params=self.get_page(page=page))
experiment_dicts = response.json()
return [
ExperimentConfig.from_dict(experiment_group)
for experiment_group in experiment_dicts.get("results", [])
]
except PolyaxonException as e:
self.handle_exception(
e=e, log_message='Error while retrieving experiments')
return []
def test_list_experiments(self):
group_uuid = uuid.uuid4().hex
project_uuid = uuid.uuid4().hex
xp_uuid = uuid.uuid4().hex
xps = [ExperimentConfig(uuid=xp_uuid,
config={},
project=project_uuid,
group=group_uuid).to_dict()
for _ in range(10)]
httpretty.register_uri(
httpretty.GET,
ExperimentGroupClient._build_url(
self.client.base_url,
ExperimentGroupClient.ENDPOINT,
'username',
'project_name',
'groups',
1,
'experiments'),
body=json.dumps({'results': xps, 'count': 10, 'next': None}),
content_type='application/json',
status=200)
response = self.client.list_experiments('username', 'project_name', 1)
assert len(response['results']) == 10
assert response['count'] == 10
assert response['next'] is None
assert response['previous'] is None
# pagination
httpretty.register_uri(
httpretty.GET,
ExperimentGroupClient._build_url(
self.client.base_url,
ExperimentGroupClient.ENDPOINT,
'username',
'project_name',
'groups',
1,
'experiments') + '?offset=2',
body=json.dumps({'results': xps, 'count': 10, 'next': None}),
content_type='application/json',
status=200)
response = self.client.list_experiments('username', 'project_name', 1, page=2)
assert len(response['results']) == 10
def test_list_experiments(self):
experiments = [
ExperimentConfig(config={}).to_dict() for _ in range(10)
]
httpretty.register_uri(httpretty.GET,
ExperimentClient._build_url(
self.client.base_url,
ExperimentClient.ENDPOINT, 'experiments'),
body=json.dumps({
'results': experiments,
'count': 10,
'next': None
}),
content_type='application/json',
status=200)
response = self.client.list_experiments()
assert len(response['results']) == 10
def run(file, description):
"""Command for running polyaxonfile specification.
Example:
```
polyaxon run -f file -f file_override ...
```
"""
file = file or 'polyaxonfile.yml'
plx_file = check_polyaxonfile(file)
num_experiments, concurrency = plx_file.experiments_def
project = get_current_project_or_exit()
project_client = PolyaxonClients().project
if num_experiments == 1:
click.echo('Creating an independent experiment.')
experiment = ExperimentConfig(
description=description,
content=plx_file._data,
config=plx_file.experiment_specs[0].parsed_data)
try:
response = project_client.create_experiment(
project.user, project.name, experiment)
except (PolyaxonHTTPError, PolyaxonShouldExitError) as e:
Printer.print_error('Could not create experiment.')
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
Printer.print_success('Experiment was created')
else:
click.echo('Creating an experiment group with {} experiments.'.format(
num_experiments))
experiment_group = ExperimentGroupConfig(description=description,
content=plx_file._data)
try:
response = project_client.create_experiment_group(
project.user, project.name, experiment_group)
Printer.print_success('Experiment group was created')
except (PolyaxonHTTPError, PolyaxonShouldExitError) as e:
Printer.print_error('Could not create experiment group.')
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
response = response.to_dict()
dict_tabulate(response)
def test_list_experiments(self):
group_uuid = uuid.uuid4().hex
project_uuid = uuid.uuid4().hex
xp_uuid = uuid.uuid4().hex
xps = [
ExperimentConfig(name='xp',
uuid=xp_uuid,
project=project_uuid,
group=group_uuid).to_dict() for _ in range(10)
]
httpretty.register_uri(httpretty.GET,
ExperimentGroupClient._build_url(
self.client.base_url,
ExperimentGroupClient.ENDPOINT, group_uuid,
'experiments'),
body=json.dumps({
'results': xps,
'count': 10,
'next': None
}),
content_type='application/json',
status=200)
xps_results = self.client.list_experiments(group_uuid)
assert len(xps_results) == 10
# pagination
httpretty.register_uri(
httpretty.GET,
ExperimentGroupClient._build_url(
self.client.base_url, ExperimentGroupClient.ENDPOINT,
group_uuid, 'experiments') + '?offset=2',
body=json.dumps({
'results': xps,
'count': 10,
'next': None
}),
content_type='application/json',
status=200)
xps_results = self.client.list_experiments(group_uuid, page=2)
assert len(xps_results) == 10
def test_experiment_with_jobs_config(self):
config_dict = {
'name':
'test',
'uuid':
uuid.uuid4().hex,
'project':
uuid.uuid4().hex,
'group':
uuid.uuid4().hex,
'jobs': [
ExperimentJobConfig(uuid.uuid4().hex,
uuid.uuid4().hex,
datetime.now(),
definition='').to_dict()
]
}
config = ExperimentConfig.from_dict(config_dict)
assert config.to_dict() == config_dict
