Refactor list commands to use share common parent class

Author: BartoszCki

paperspace/cli/deployments.py

@@ -105,7 +105,7 @@ def get_deployments_list(api_key=None, **filters):
     del_if_value_is_none(filters)
     deployments_api = client.API(config.CONFIG_HOST, api_key=api_key)
     command = deployments_commands.ListDeploymentsCommand(api=deployments_api)
-    command.execute(filters)
+    command.execute(filters=filters)
 
 
 @deployments.command("update", help="Update deployment properties")

paperspace/cli/experiments.py

@@ -294,7 +294,7 @@ def stop_experiment(experiment_id, api_key):
 def list_experiments(project_ids, api_key):
     experiments_api = client.API(config.CONFIG_EXPERIMENTS_HOST, api_key=api_key)
     command = experiments_commands.ListExperimentsCommand(api=experiments_api)
-    command.execute(project_ids)
+    command.execute(project_ids=project_ids)
 
 
 @experiments.command("details", help="Show detail of an experiment")

paperspace/cli/jobs.py

@@ -62,7 +62,7 @@ def list_jobs(api_key, **filters):
     common.del_if_value_is_none(filters)
     jobs_api = client.API(config.CONFIG_HOST, api_key=api_key)
     command = jobs_commands.ListJobsCommand(api=jobs_api)
-    command.execute(filters)
+    command.execute(filters=filters)
 
 
 @jobs_group.command("create", help="Create job")

paperspace/cli/machines.py

@@ -360,7 +360,8 @@ def list_machines(api_key, params, **kwargs):
 
     machines_api = client.API(config.CONFIG_HOST, api_key=api_key)
     command = machines_commands.ListMachinesCommand(api=machines_api)
-    command.execute(params or kwargs)
+    filters = params or kwargs
+    command.execute(filters=filters)
 
 
 restart_machine_help = "Restart an individual machine. If the machine is already restarting, this action will " \

paperspace/cli/models.py

@@ -27,4 +27,4 @@ def list_models(api_key, **filters):
     common.del_if_value_is_none(filters)
     models_api = client.API(config.CONFIG_HOST, api_key=api_key)
     command = models_commands.ListModelsCommand(api=models_api)
-    command.execute(filters)
+    command.execute(filters=filters)

paperspace/commands/__init__.py

@@ -1,7 +0,0 @@
-from paperspace import logger
-
-
-class CommandBase(object):
-    def __init__(self, api=None, logger_=logger):
-        self.api = api
-        self.logger = logger_

paperspace/commands/common.py

@@ -0,0 +1,69 @@
+import pydoc
+
+import terminaltables
+
+from paperspace import logger
+from paperspace.utils import get_terminal_lines
+
+
+class CommandBase(object):
+    def __init__(self, api=None, logger_=logger):
+        self.api = api
+        self.logger = logger_
+
+
+class ListCommand(CommandBase):
+    @property
+    def request_url(self):
+        raise NotImplementedError()
+
+    def execute(self, **kwargs):
+        response = self._get_response(kwargs)
+
+        try:
+            if not response.ok:
+                self.logger.log_error_response(response.json())
+                return
+
+            objects = self._get_objects(response, kwargs)
+        except (ValueError, KeyError) as e:
+            self.logger.error("Error while parsing response data: {}".format(e))
+        else:
+            self._log_objects_list(objects)
+
+    def _log_objects_list(self, objects):
+        if not objects:
+            self.logger.warning("No data found")
+            return
+
+        table_data = self._get_table_data(objects)
+        table_str = self._make_table(table_data)
+        if len(table_str.splitlines()) > get_terminal_lines():
+            pydoc.pager(table_str)
+        else:
+            self.logger.log(table_str)
+
+    def _get_objects(self, response, kwargs):
+        data = response.json()
+        return data
+
+    def _get_response(self, kwargs):
+        json_ = self._get_request_json(kwargs)
+        params = self._get_request_params(kwargs)
+        response = self.api.get(self.request_url, json=json_, params=params)
+        return response
+
+    def _get_table_data(self, objects):
+        raise NotImplementedError()
+
+    @staticmethod
+    def _make_table(table_data):
+        ascii_table = terminaltables.AsciiTable(table_data)
+        table_string = ascii_table.table
+        return table_string
+
+    def _get_request_json(self, kwargs):
+        return None
+
+    def _get_request_params(self, kwargs):
+        return None

paperspace/commands/deployments.py

@@ -1,10 +1,8 @@
-import pydoc
-
 import terminaltables
 
-from paperspace import config, version, client, logger
-from paperspace.commands import CommandBase
-from paperspace.utils import get_terminal_lines
+from paperspace import config, version, client
+from paperspace.commands import common
+from paperspace.commands.common import CommandBase
 
 default_headers = {"X-API-Key": config.PAPERSPACE_API_KEY,
                    "ps_client_name": "paperspace-python",
@@ -39,51 +37,25 @@ def execute(self, kwargs):
                           "Unknown error during deployment")
 
 
-class ListDeploymentsCommand(_DeploymentCommandBase):
-    def execute(self, filters=None):
-        json_ = self._get_request_json(filters)
-        response = self.api.get("/deployments/getDeploymentList/", json=json_)
+class ListDeploymentsCommand(common.ListCommand):
+    @property
+    def request_url(self):
+        return "/deployments/getDeploymentList/"
 
-        try:
-            data = response.json()
-            if not response.ok:
-                self.logger.log_error_response(data)
-                return
-            deployments = self._get_deployments_list(response)
-        except (ValueError, KeyError) as e:
-            self.logger.error("Error while parsing response data: {}".format(e))
-        else:
-            self._log_deployments_list(deployments)
-
-    @staticmethod
-    def _get_request_json(filters):
+    def _get_request_json(self, kwargs):
+        filters = kwargs.get("filters")
         if not filters:
             return None
 
         json_ = {"filter": {"where": {"and": [filters]}}}
         return json_
 
-    @staticmethod
-    def _get_deployments_list(response):
-        if not response.ok:
-            raise ValueError("Unknown error")
-
-        data = response.json()["deploymentList"]
-        logger.debug(data)
-        return data
+    def _get_objects(self, response, kwargs):
+        data = super(ListDeploymentsCommand, self)._get_objects(response, kwargs)
+        objects = data["deploymentList"]
+        return objects
 
-    def _log_deployments_list(self, deployments):
-        if not deployments:
-            self.logger.warning("No deployments found")
-        else:
-            table_str = self._make_deployments_list_table(deployments)
-            if len(table_str.splitlines()) > get_terminal_lines():
-                pydoc.pager(table_str)
-            else:
-                self.logger.log(table_str)
-
-    @staticmethod
-    def _make_deployments_list_table(deployments):
+    def _get_table_data(self, deployments):
         data = [("Name", "ID", "Endpoint", "Api Type", "Deployment Type")]
         for deployment in deployments:
             name = deployment.get("name")
@@ -93,9 +65,7 @@ def _make_deployments_list_table(deployments):
             deployment_type = deployment.get("deploymentType")
             data.append((name, id_, endpoint, api_type, deployment_type))
 
-        ascii_table = terminaltables.AsciiTable(data)
-        table_string = ascii_table.table
-        return table_string
+        return data
 
 
 class UpdateDeploymentCommand(_DeploymentCommandBase):

paperspace/commands/experiments.py

@@ -3,15 +3,15 @@
 import terminaltables
 
 from paperspace import logger, constants, client, config
-from paperspace.commands import CommandBase
 from paperspace.workspace import S3WorkspaceHandler
 from paperspace.logger import log_response
 from paperspace.utils import get_terminal_lines
+from . import common
 
 experiments_api = client.API(config.CONFIG_EXPERIMENTS_HOST, headers=client.default_headers)
 
 
-class ExperimentCommand(CommandBase):
+class ExperimentCommand(common.CommandBase):
     def __init__(self, workspace_handler=None, **kwargs):
         super(ExperimentCommand, self).__init__(**kwargs)
         self._workspace_handler = workspace_handler or S3WorkspaceHandler(experiments_api=self.api, logger=self.logger)
@@ -68,52 +68,36 @@ def stop_experiment(experiment_id, api=experiments_api):
     log_response(response, "Experiment stopped", "Unknown error while stopping the experiment")
 
 
-class ListExperimentsCommand(object):
-    def __init__(self, api=experiments_api, logger_=logger):
-        self.api = api
-        self.logger = logger_
+class ListExperimentsCommand(common.ListCommand):
+    @property
+    def request_url(self):
+        return "/experiments/"
 
-    def execute(self, project_ids=None):
-        project_ids = project_ids or []
-        params = self._get_query_params(project_ids)
-        response = self.api.get("/experiments/", params=params)
-
-        try:
-            data = response.json()
-            if not response.ok:
-                self.logger.log_error_response(data)
-                return
-
-            experiments = self._get_experiments_list(data, bool(project_ids))
-        except (ValueError, KeyError) as e:
-            self.logger.error("Error while parsing response data: {}".format(e))
-        else:
-            self._log_experiments_list(experiments)
-
-    @staticmethod
-    def _get_query_params(project_ids):
+    def _get_request_params(self, kwargs):
         params = {"limit": -1}  # so the API sends back full list without pagination
-        for i, experiment_id in enumerate(project_ids):
-            key = "projectHandle[{}]".format(i)
-            params[key] = experiment_id
+
+        project_ids = kwargs.get("project_ids")
+        if project_ids:
+            for i, experiment_id in enumerate(project_ids):
+                key = "projectHandle[{}]".format(i)
+                params[key] = experiment_id
 
         return params
 
-    @staticmethod
-    def _make_experiments_list_table(experiments):
+    def _get_table_data(self, experiments):
         data = [("Name", "ID", "Status")]
         for experiment in experiments:
             name = experiment["templateHistory"]["params"].get("name")
             handle = experiment["handle"]
             status = constants.ExperimentState.get_state_str(experiment["state"])
             data.append((name, handle, status))
 
-        ascii_table = terminaltables.AsciiTable(data)
-        table_string = ascii_table.table
-        return table_string
+        return data
+
+    def _get_objects(self, response, kwargs):
+        data = super(ListExperimentsCommand, self)._get_objects(response, kwargs)
 
-    @staticmethod
-    def _get_experiments_list(data, filtered=False):
+        filtered = bool(kwargs.get("project_ids"))
         if not filtered:  # If filtering by project ID response data has different format...
             return data["data"]
 
@@ -123,16 +107,6 @@ def _get_experiments_list(data, filtered=False):
                 experiments.append(experiment)
         return experiments
 
-    def _log_experiments_list(self, experiments):
-        if not experiments:
-            self.logger.warning("No experiments found")
-        else:
-            table_str = self._make_experiments_list_table(experiments)
-            if len(table_str.splitlines()) > get_terminal_lines():
-                pydoc.pager(table_str)
-            else:
-                self.logger.log(table_str)
-
 
 def _make_details_table(experiment):
     if experiment["experimentTypeId"] == constants.ExperimentType.SINGLE_NODE:

paperspace/commands/jobs.py

@@ -4,9 +4,10 @@
 from click import style
 
 from paperspace import config, client
-from paperspace.commands import CommandBase
+from paperspace.commands.common import CommandBase
 from paperspace.utils import get_terminal_lines
 from paperspace.workspace import S3WorkspaceHandler
+from . import common
 
 
 class JobsCommandBase(CommandBase):
@@ -45,33 +46,17 @@ def execute(self, job_id):
                           "Unknown error while stopping job")
 
 
-class ListJobsCommand(JobsCommandBase):
-    def execute(self, filters=None):
-        json_ = filters or None
-        response = self.api.get("/jobs/getJobs/", json=json_)
-
-        try:
-            data = response.json()
-            if not response.ok:
-                self.logger.log_error_response(data)
-                return
-        except (ValueError, KeyError) as e:
-            self.logger.error("Error while parsing response data: {}".format(e))
-        else:
-            self._log_jobs_list(data)
+class ListJobsCommand(common.ListCommand):
+    @property
+    def request_url(self):
+        return "/jobs/getJobs/"
 
-    def _log_jobs_list(self, data):
-        if not data:
-            self.logger.warning("No jobs found")
-        else:
-            table_str = self._make_table(data)
-            if len(table_str.splitlines()) > get_terminal_lines():
-                pydoc.pager(table_str)
-            else:
-                self.logger.log(table_str)
+    def _get_request_json(self, kwargs):
+        filters = kwargs.get("filters")
+        json_ = filters or None
+        return json_
 
-    @staticmethod
-    def _make_table(jobs):
+    def _get_table_data(self, jobs):
         data = [("ID", "Name", "Project", "Cluster", "Machine Type", "Created")]
         for job in jobs:
             id_ = job.get("id")
@@ -82,9 +67,7 @@ def _make_table(jobs):
             created = job.get("dtCreated")
             data.append((id_, name, project, cluster, machine_type, created))
 
-        ascii_table = terminaltables.AsciiTable(data)
-        table_string = ascii_table.table
-        return table_string
+        return data
 
 
 class JobLogsCommand(CommandBase):