getting artifacts, some rearangement

Author: kossak

paperspace/cli/jobs.py

@@ -106,11 +106,25 @@ def list_logs(job_id, api_key=None):
     command.execute(job_id)
 
 
-@jobs_group.command("artifactsDestroy", help="Destroy job's artifacts")
+@jobs_group.group("artifacts", help="Manage jobs' artifacts", cls=ClickGroup)
+def artifacts():
+    pass
+
+
+@artifacts.command("destroy", help="Destroy job's artifacts")
 @click.argument("job_id")
 @click.option("--files", "files")
 @api_key_option
 def destroy_artifacts(job_id, api_key=None, files=None):
     jobs_api = client.API(config.CONFIG_HOST, api_key=api_key)
     command = jobs_commands.ArtifactsDestroyCommand(api=jobs_api)
     command.execute(job_id, files=files)
+
+
+@artifacts.command("get", help="Get job's artifacts")
+@click.argument("job_id")
+@api_key_option
+def get_artifacts(job_id, api_key=None):
+    jobs_api = client.API(config.CONFIG_HOST, api_key=api_key)
+    command = jobs_commands.ArtifactsGetCommand(api=jobs_api)
+    command.execute(job_id)

paperspace/commands/__init__.py

@@ -1,7 +1,17 @@
+from collections import OrderedDict
+
 from paperspace import logger
 
 
 class CommandBase(object):
     def __init__(self, api=None, logger_=logger):
         self.api = api
         self.logger = logger_
+
+    def _print_dict_recursive(self, input_dict, indent=0, tabulator="  "):
+        for key, val in input_dict.items():
+            self.logger.log("%s%s:" % (tabulator * indent, key))
+            if type(val) is dict:
+                self._print_dict_recursive(OrderedDict(val), indent + 1)
+            else:
+                self.logger.log("%s%s" % (tabulator * (indent + 1), val))

paperspace/commands/jobs.py

@@ -5,6 +5,7 @@
 
 from paperspace import config, client
 from paperspace.commands import CommandBase
+from paperspace.exceptions import BadResponseError
 from paperspace.utils import get_terminal_lines
 from paperspace.workspace import S3WorkspaceHandler
 
@@ -168,3 +169,22 @@ def execute(self, job_id, files=None):
             params = {'files': files}
         response = self.api.post(url, params=params)
         self._log_message(response, "Artifacts destroyed", "Unknown error while destroying artifacts")
+
+
+class ArtifactsGetCommand(JobsCommandBase):
+    def execute(self, job_id):
+        url = '/jobs/artifactsGet'
+        response = self.api.get(url, params={'jobId': job_id})
+
+        self._log_artifacts(response)
+
+    def _log_artifacts(self, response):
+        try:
+            artifacts_json = response.json()
+            if response.ok:
+                self._print_dict_recursive(artifacts_json)
+            else:
+                raise BadResponseError(
+                    '{}: {}'.format(artifacts_json['error']['status'], artifacts_json['error']['message']))
+        except (ValueError, KeyError, BadResponseError) as e:
+            self.logger.error("Error occurred while getting artifacts: {}".format(str(e)))

tests/functional/test_jobs.py

@@ -265,26 +265,38 @@ class TestJobArtifactsCommands(TestJobs):
     @mock.patch("paperspace.client.requests.post")
     def test_should_send_valid_post_request_when_destroying_artifacts_with_files_specified(self, post_patched):
         post_patched.return_value = MockResponse(status_code=200)
-        job_id = 'some_job_id'
-        file_names = 'some_file_names'
-        result = self.runner.invoke(cli.cli, ['jobs', 'artifactsDestroy', job_id, '--files', file_names, "--apiKey", "some_key"])
+        job_id = "some_job_id"
+        file_names = "some_file_names"
+        result = self.runner.invoke(cli.cli, ["jobs", "artifacts", "destroy", job_id, "--files", file_names, "--apiKey", "some_key"])
 
-        post_patched.assert_called_with('{}/jobs/{}/artifactsDestroy'.format(self.URL, job_id),
+        post_patched.assert_called_with("{}/jobs/{}/artifactsDestroy".format(self.URL, job_id),
                                         files=None,
                                         headers=self.EXPECTED_HEADERS_WITH_CHANGED_API_KEY,
                                         json=None,
-                                        params={'files': file_names})
+                                        params={"files": file_names})
         assert result.exit_code == 0
 
     @mock.patch("paperspace.client.requests.post")
     def test_should_send_valid_post_request_when_destroying_artifacts_without_files_specified(self, post_patched):
         post_patched.return_value = MockResponse(status_code=200)
-        job_id = 'some_job_id'
-        result = self.runner.invoke(cli.cli, ['jobs', 'artifactsDestroy', job_id, "--apiKey", "some_key"])
+        job_id = "some_job_id"
+        result = self.runner.invoke(cli.cli, ["jobs", "artifacts", "destroy", job_id, "--apiKey", "some_key"])
 
-        post_patched.assert_called_with('{}/jobs/{}/artifactsDestroy'.format(self.URL, job_id),
+        post_patched.assert_called_with("{}/jobs/{}/artifactsDestroy".format(self.URL, job_id),
                                         files=None,
                                         headers=self.EXPECTED_HEADERS_WITH_CHANGED_API_KEY,
                                         json=None,
                                         params=None)
         assert result.exit_code == 0
+
+    @mock.patch("paperspace.client.requests.get")
+    def test_should_send_send_valid_get_request_and_receive_json_response(self, get_patched):
+        get_patched.return_value = MockResponse(status_code=200)
+        job_id = "some_job_id"
+        result = self.runner.invoke(cli.cli, ["jobs", "artifacts", "get", job_id, "--apiKey", "some_key"])
+
+        get_patched.assert_called_with("{}/jobs/artifactsGet".format(self.URL),
+                                       headers=self.EXPECTED_HEADERS_WITH_CHANGED_API_KEY,
+                                       json=None,
+                                       params={"jobId": job_id})
+        assert result.exit_code == 0

tests/unit/test_base.py

@@ -0,0 +1,45 @@
+from collections import OrderedDict
+
+import mock
+import pytest
+
+from paperspace.commands import CommandBase
+
+output_response = ""
+
+
+class TestBaseClass(object):
+    def test_json_print(self):
+        global output_response
+        output_response = ""
+
+        def log_to_var(message):
+            global output_response
+            output_response = "{}{}\n".format(output_response, message)
+
+        logger_ = mock.MagicMock()
+        logger_.log = log_to_var
+
+        input_dict = {
+            "foo": "bar",
+            "baz": {
+                "foo2": "bar2",
+                'baz2': {
+                    "foo3": "bar3"
+                }
+            }
+        }
+        expected_string = """foo:
+  bar
+baz:
+  baz2:
+    foo3:
+      bar3
+  foo2:
+    bar2
+"""
+
+        command = CommandBase(logger_=logger_)
+        command._print_dict_recursive(OrderedDict(input_dict))
+
+        assert output_response == expected_string