def __init__(self, filepaths, params=None, debug_ttl=False):
filepaths = to_list(filepaths)
for filepath in filepaths:
if not os.path.isfile(filepath):
raise PolyaxonfileError(
"`{}` must be a valid file".format(filepath))
self._filenames = [
os.path.basename(filepath) for filepath in filepaths
]
if params:
if not isinstance(params, Mapping):
raise PolyaxonfileError(
"Params: `{}` must be a valid mapping".format(params))
filepaths.append({'params': params})
if debug_ttl:
if not isinstance(debug_ttl, int):
raise PolyaxonfileError(
"Debug TTL `{}` must be a valid integer".format(debug_ttl))
filepaths.append({'run': {'cmd': 'sleep {}'.format(debug_ttl)}})
data = rhea.read(filepaths)
kind = BaseSpecification.get_kind(data=data)
debug_cond = (debug_ttl
and not (BaseSpecification.check_kind_experiment(kind)
or BaseSpecification.check_kind_job(kind)))
if debug_cond:
raise PolyaxonfileError(
'You can only trigger debug mode on a job or an experiment specification, '
'received instead a `{}` specification'.format(kind))
try:
self.specification = SPECIFICATION_BY_KIND[kind](data)
except PolyaxonConfigurationError as e:
raise PolyaxonfileError(e)
def resume(ctx, file, u): # pylint:disable=redefined-builtin
"""Resume experiment.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
\b
```bash
$ polyaxon experiment --experiment=1 resume
```
"""
config = None
update_code = None
if file:
config = rhea.read(file)
# Check if we need to upload
if u:
ctx.invoke(upload, sync=False)
update_code = True
user, project_name, _experiment = get_project_experiment_or_local(ctx.obj.get('project'),
ctx.obj.get('experiment'))
try:
response = PolyaxonClient().experiment.resume(
user, project_name, _experiment, config=config, update_code=update_code)
Printer.print_success('Experiment was resumed with id {}'.format(response.id))
except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:
Printer.print_error('Could not resume experiment `{}`.'.format(_experiment))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
def resume(ctx, polyaxonfile, u):
"""Resume run.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
\b
```bash
$ polyaxon runs --uid=8aac02e3a62a4f0aaa257c59da5eab80 resume
```
"""
content = None
if polyaxonfile:
content = "{}".format(rhea.read(polyaxonfile))
# Check if we need to upload
if u:
ctx.invoke(upload, sync=False)
owner, project_name, run_uuid = get_project_run_or_local(
ctx.obj.get("project"), ctx.obj.get("run_uuid"))
try:
polyaxon_client = PolyaxonClient()
body = V1Run(content=content)
response = polyaxon_client.runs_v1.resume_run(owner, project_name,
run_uuid, body)
Printer.print_success("Run was resumed with uid {}".format(
response.uuid))
except (ApiException, HTTPError) as e:
handle_cli_error(e,
message="Could not resume run `{}`.".format(run_uuid))
sys.exit(1)
def __init__(self, filepaths):
filepaths = to_list(filepaths)
for filepath in filepaths:
if not os.path.isfile(filepath):
raise PolyaxonfileError(
"`{}` must be a valid file".format(filepath))
self._filenames = [
os.path.basename(filepath) for filepath in filepaths
]
self.specification = get_specification(data=rhea.read(filepaths))
def __init__(self, filepaths):
filepaths = to_list(filepaths)
for filepath in filepaths:
if not os.path.isfile(filepath):
raise PolyaxonfileError(
"`{}` must be a valid file".format(filepath))
self._filenames = [
os.path.basename(filepath) for filepath in filepaths
]
data = rhea.read(filepaths)
kind = BaseSpecification.get_kind(data=data)
try:
self.specification = SPECIFICATION_BY_KIND[kind](data)
except PolyaxonConfigurationError as e:
raise PolyaxonfileError(e)
def __init__(self, values):
self._values = to_list(values)
try:
self._data = rhea.read([{
"kind": self._SPEC_KIND,
"version": SCHEMA_VERSION
}] + self._values)
except rhea.RheaError as e:
raise PolyaxonSchemaError("%s" % e)
try:
self._config = self.CONFIG.from_dict(copy.deepcopy(self.data))
except (ValidationError, TypeError) as e:
raise PolyaxonfileError(
"Received a non valid config `{}`: `{}`".format(
self._SPEC_KIND, e))
self.check_data()
self._extra_validation()
def __init__(self, values):
self._values = to_list(values)
try:
self._data = rhea.read(self._values)
except rhea.RheaError as e:
raise PolyaxonConfigurationError(e)
self.check_data()
headers = Parser.get_headers(spec=self, data=self._data)
try:
self._headers = validator.validate_headers(spec=self, data=headers)
except ValidationError as e:
raise PolyaxonConfigurationError(e)
self._parsed_data = None
self._validated_data = None
self._config = None
self._set_parsed_data()
self._extra_validation()
def restart(ctx, copy, file, u): # pylint:disable=redefined-builtin
"""Restart job.
Uses [Caching](/references/polyaxon-cli/#caching)
Examples:
\b
```bash
$ polyaxon job --job=1 restart
```
"""
content = None
update_code = None
if file:
content = '{}'.format(rhea.read(file))
# Check if we need to upload
if u:
ctx.invoke(upload, sync=False)
update_code = True
user, project_name, _job = get_job_or_local(ctx.obj.get('project'),
ctx.obj.get('job'))
try:
if copy:
response = PolyaxonClient().job.copy(user,
project_name,
_job,
content=content,
update_code=update_code)
else:
response = PolyaxonClient().job.restart(user,
project_name,
_job,
content=content,
update_code=update_code)
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error('Could not restart job `{}`.'.format(_job))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
get_job_details(response)
def resume(ctx, file, u): # pylint:disable=redefined-builtin
"""Resume job.
Uses [Caching](/polyaxon_cli/introduction#Caching)
Examples:
\b
```bash
$ polyaxon job --job=1 resume
```
"""
config = None
update_code = None
if file:
config = rhea.read(file)
# Check if we need to upload
if u:
ctx.invoke(upload)
update_code = True
user, project_name, _job = get_job_or_local(ctx.obj.get('project'),
ctx.obj.get('job'))
try:
response = PolyaxonClient().job.resume(user,
project_name,
_job,
config=config,
update_code=update_code)
except (PolyaxonHTTPError, PolyaxonShouldExitError,
PolyaxonClientException) as e:
Printer.print_error('Could not resume job `{}`.'.format(_job))
Printer.print_error('Error message `{}`.'.format(e))
sys.exit(1)
get_job_details(response)
def generate(polyaxonfile, build_context, destination, params):
"""Generate a dockerfile given the polyaxonfile."""
if all([polyaxonfile, build_context]):
Printer.print_error(
"Only a polyaxonfile or a build context option is required.")
sys.exit(1)
if build_context:
try:
build_context = BuildContextConfig.from_dict(
rhea.read(build_context))
except (RheaError, ValidationError) as e:
Printer.print_error("received a non valid build context.")
Printer.print_error("Error message: {}.".format(e))
sys.exit(1)
else:
specification = check_polyaxonfile(polyaxonfile,
params=params,
log=False)
try:
run_spec = get_specification(specification.generate_run_data())
run_spec.apply_params(params=specification.config.params)
run_spec.apply_context()
except PolyaxonSchemaError:
Printer.print_error(
"Could not run this polyaxonfile locally, "
"a context is required to resolve it dependencies.")
sys.exit(1)
build_context = run_spec.build_context
generator = DockerFileGenerator(build_context=build_context,
destination=destination or ".")
generator.create()
Printer.print_success("Dockerfile was generated: `{}`".format(
generator.dockerfile_path))
def get_specification(data):
data = rhea.read(data)
kind = BaseSpecification.get_kind(data=data)
return SPECIFICATION_BY_KIND[kind](data)
def read(filepaths):
data = rhea.read(filepaths)
return DeploymentConfig.from_dict(data)
