Migrate endpoints and tests to new mythx models

Author: dmuhs

pythx/__init__.py

@@ -4,6 +4,5 @@
 __email__ = "[email protected]"
 __version__ = "1.6.2"
 
-from mythx_models.exceptions import MythXAPIError, MythXBaseException, ValidationError
-
+from mythx_models.exceptions import MythXAPIError
 from pythx.api.client import Client

pythx/api/client.py

@@ -7,9 +7,7 @@
 import jwt
 from mythx_models import request as reqmodels
 from mythx_models import response as respmodels
-from mythx_models.request.base import BaseRequest
-from mythx_models.response.base import BaseResponse
-
+from pythx.types import RESPONSE_MODELS, REQUEST_MODELS
 from pythx.api.handler import APIHandler
 from pythx.middleware import (
     AnalysisCacheMiddleware,
@@ -52,7 +50,7 @@ def __init__(
         refresh_token: str = None,
         handler: APIHandler = None,
         no_cache: bool = False,
-        middlewares: List[Type[BaseMiddleware]] = None,
+        middlewares: List[BaseMiddleware] = None,
         api_url: str = None,
     ):
         """Instantiate a new MythX API client.
@@ -101,11 +99,11 @@ class unless a custom instance has already been provided.
 
     def _assemble_send_parse(
         self,
-        req_obj: Type[BaseRequest],
-        resp_model: Type[BaseResponse],
+        req_obj: REQUEST_MODELS,
+        resp_model: Type[RESPONSE_MODELS],
         assert_authentication: bool = True,
         include_auth_header: bool = True,
-    ) -> Type[BaseResponse]:
+    ) -> RESPONSE_MODELS:
         """Assemble the request, send it, parse and return the response.
 
         This method takes a request model instance and:
@@ -189,13 +187,13 @@ def login(self) -> respmodels.AuthLoginResponse:
         :return: :code:`AuthLoginResponse`
         """
         req = reqmodels.AuthLoginRequest(username=self.username, password=self.password)
-        resp_model = self._assemble_send_parse(
+        resp_model: respmodels.AuthLoginResponse = self._assemble_send_parse(
             req,
             respmodels.AuthLoginResponse,
             assert_authentication=False,
             include_auth_header=False,
         )
-        self.api_key = resp_model.api_key
+        self.api_key = resp_model.access_token
         self.refresh_token = resp_model.refresh_token
         return resp_model
 
@@ -204,7 +202,7 @@ def logout(self) -> respmodels.AuthLogoutResponse:
 
         :return: :code:`AuthLogoutResponse`
         """
-        req = reqmodels.AuthLogoutRequest()
+        req = reqmodels.AuthLogoutRequest(**{"global": True})
         resp_model = self._assemble_send_parse(req, respmodels.AuthLogoutResponse)
         self.api_key = None
         self.refresh_token = None
@@ -218,7 +216,7 @@ def refresh(self) -> respmodels.AuthRefreshResponse:
         req = reqmodels.AuthRefreshRequest(
             access_token=self.api_key, refresh_token=self.refresh_token
         )
-        resp_model = self._assemble_send_parse(
+        resp_model: respmodels.AuthRefreshResponse = self._assemble_send_parse(
             req,
             respmodels.AuthRefreshResponse,
             assert_authentication=False,
@@ -228,6 +226,76 @@ def refresh(self) -> respmodels.AuthRefreshResponse:
         self.refresh_token = resp_model.refresh_token
         return resp_model
 
+    def project_list(
+        self, offset: int = None, limit: int = None, name: str = ""
+    ) -> respmodels.ProjectListResponse:
+        """List the existing projects on the platform
+
+        :param offset: The number of projects to skip (optional)
+        :param limit: The number of projects to return (optional)
+        :param name: The name to filter projects by (optional)
+        :return:
+        """
+        req = reqmodels.ProjectListRequest(
+            offset=offset,
+            limit=limit,
+            name=name,
+        )
+        return self._assemble_send_parse(req, respmodels.ProjectListResponse)
+
+    def project_status(self, project_id: str = "") -> respmodels.ProjectStatusResponse:
+        """Get detailed information for a project.
+
+        :param project_id: The project's ID
+        :return: :code:`ProjectStatusResponse`
+        """
+        req = reqmodels.ProjectStatusRequest(project_id=project_id)
+        return self._assemble_send_parse(req, respmodels.ProjectStatusResponse)
+
+    def delete_project(
+        self, project_id: str = ""
+    ) -> respmodels.ProjectDeletionResponse:
+        """Delete an existing project.
+
+        :param project_id: The project's ID
+        :return: :code:`ProjectDeletionResponse`
+        """
+        req = reqmodels.ProjectDeleteRequest(project_id=project_id)
+        return self._assemble_send_parse(req, respmodels.ProjectDeletionResponse)
+
+    def create_project(
+        self, name: str = "", description: str = "", groups: List[str] = None
+    ) -> respmodels.ProjectCreationResponse:
+        """Create a new project.
+
+        :param name: The project name
+        :param description: The project description
+        :param groups: List of group IDs belonging to the project (optional)
+        :return: :code:`ProjectCreationResponse`
+        """
+        req = reqmodels.ProjectCreationRequest(
+            name=name, description=description, groups=groups or []
+        )
+        return self._assemble_send_parse(req, respmodels.ProjectCreationResponse)
+
+    def update_project(
+        self, project_id: str = "", name: str = "", description: str = ""
+    ) -> respmodels.ProjectUpdateResponse:
+        """Update an existing project.
+
+        A new name, a new description, or both should be given.
+
+        :param project_id: The ID of the project to update
+        :param name: The new project name (optional)
+        :param description: The new project description (optional)
+        :return: :code:`ProjectUpdateResponse`
+        """
+
+        req = reqmodels.ProjectUpdateRequest(
+            project_id=project_id, name=name, description=description
+        )
+        return self._assemble_send_parse(req, respmodels.ProjectUpdateResponse)
+
     def group_list(
         self,
         offset: int = None,
@@ -288,13 +356,13 @@ def analysis_list(
 
     def analyze(
         self,
-        contract_name: str = None,
         bytecode: str = None,
+        main_source: str = None,
+        sources: Dict[str, Dict[str, str]] = None,
+        contract_name: str = None,
         source_map: str = None,
         deployed_bytecode: str = None,
         deployed_source_map: str = None,
-        main_source: str = None,
-        sources: Dict[str, Dict[str, str]] = None,
         source_list: List[str] = None,
         solc_version: str = None,
         analysis_mode: str = "quick",
@@ -330,7 +398,6 @@ def analyze(
             solc_version=solc_version,
             analysis_mode=analysis_mode,
         )
-        # req.validate()
         return self._assemble_send_parse(req, respmodels.AnalysisSubmissionResponse)
 
     def group_status(self, group_id: str) -> respmodels.GroupStatusResponse:
@@ -342,14 +409,13 @@ def group_status(self, group_id: str) -> respmodels.GroupStatusResponse:
         req = reqmodels.GroupStatusRequest(group_id=group_id)
         return self._assemble_send_parse(req, respmodels.GroupStatusResponse)
 
-    def status(self, uuid: str) -> respmodels.AnalysisStatusResponse:
+    def analysis_status(self, uuid: str) -> respmodels.AnalysisStatusResponse:
         """Get the status of an analysis job based on its UUID.
 
         :param uuid: The job's UUID
         :return: :code:`AnalysisStatusResponse`
         """
-        # TODO: rename to analysis_status
-        req = reqmodels.AnalysisStatusRequest(uuid)
+        req = reqmodels.AnalysisStatusRequest(uuid=uuid)
         return self._assemble_send_parse(req, respmodels.AnalysisStatusResponse)
 
     def analysis_ready(self, uuid: str) -> bool:
@@ -359,10 +425,10 @@ def analysis_ready(self, uuid: str) -> bool:
         :param uuid: The analysis job UUID
         :return: bool indicating whether the analysis has finished
         """
-        resp = self.status(uuid)
+        resp = self.analysis_status(uuid)
         return (
-            resp.analysis.status == respmodels.AnalysisStatus.FINISHED
-            or resp.analysis.status == respmodels.AnalysisStatus.ERROR
+            resp.status == respmodels.AnalysisStatus.FINISHED
+            or resp.status == respmodels.AnalysisStatus.ERROR
         )
 
     def report(self, uuid: str) -> respmodels.DetectedIssuesResponse:
@@ -372,7 +438,7 @@ def report(self, uuid: str) -> respmodels.DetectedIssuesResponse:
         :param uuid: The analysis job UUID
         :return: :code:`DetectedIssuesResponse`
         """
-        req = reqmodels.DetectedIssuesRequest(uuid)
+        req = reqmodels.DetectedIssuesRequest(uuid=uuid)
         return self._assemble_send_parse(req, respmodels.DetectedIssuesResponse)
 
     def request_by_uuid(self, uuid: str) -> respmodels.AnalysisInputResponse:
@@ -381,7 +447,7 @@ def request_by_uuid(self, uuid: str) -> respmodels.AnalysisInputResponse:
         :param uuid: The analysis job UUID
         :return: :code:`AnalysisInputResponse`
         """
-        req = reqmodels.AnalysisInputRequest(uuid)
+        req = reqmodels.AnalysisInputRequest(uuid=uuid)
         return self._assemble_send_parse(req, respmodels.AnalysisInputResponse)
 
     def create_group(self, group_name: str = "") -> respmodels.GroupCreationResponse:
@@ -404,20 +470,6 @@ def seal_group(self, group_id: str) -> respmodels.GroupOperationResponse:
         req = reqmodels.GroupOperationRequest(group_id=group_id, type_="seal_group")
         return self._assemble_send_parse(req, respmodels.GroupOperationResponse)
 
-    def openapi(self, mode: str = "yaml") -> respmodels.OASResponse:
-        """Return the OpenAPI specification either in HTML or YAML.
-
-        :param mode: "yaml" or "html"
-        :return: :code:`OASResponse`
-        """
-        req = reqmodels.OASRequest(mode=mode)
-        return self._assemble_send_parse(
-            req,
-            respmodels.OASResponse,
-            assert_authentication=False,
-            include_auth_header=False,
-        )
-
     def version(self) -> respmodels.VersionResponse:
         """Call the APIs version endpoint to get its backend version numbers.
 

pythx/api/handler.py

@@ -1,18 +1,16 @@
 """This module contains the API request handler implementation."""
-
+from json import JSONDecodeError
 import logging
 import os
 import re
 import urllib.parse
 from typing import Dict, List, Type
-
 import requests
 from mythx_models.exceptions import MythXAPIError
-from mythx_models.request.base import BaseRequest
-from mythx_models.response.base import BaseResponse
-
+from mythx_models.response import DetectedIssuesResponse, IssueReport
+from pythx.types import RESPONSE_MODELS, REQUEST_MODELS
 from pythx.middleware.base import BaseMiddleware
-
+from pydantic import parse_obj_as
 DEFAULT_API_URL = "https://api.mythx.io/"
 
 
@@ -56,7 +54,7 @@ class APIHandler:
     """
 
     def __init__(
-        self, middlewares: List[Type[BaseMiddleware]] = None, api_url: str = None
+        self, middlewares: List[BaseMiddleware] = None, api_url: str = None
     ):
         """Instantiate a new API handler class.
 
@@ -85,7 +83,7 @@ def _normalize_url(url: str) -> str:
         return url + "/" if not url.endswith("/") else url
 
     @staticmethod
-    def send_request(request_data: Dict, auth_header: Dict[str, str] = None) -> str:
+    def send_request(request_data: Dict, auth_header: Dict[str, str] = None) -> Dict:
         """Send a request to the API.
 
         This method takes a data dictionary holding the request's method (HTTP verb),
@@ -100,7 +98,7 @@ def send_request(request_data: Dict, auth_header: Dict[str, str] = None) -> str:
             {
                 "method": "GET",
                 "headers": {},
-                "url": "https://api.mythx.io/v1/analyses/6b9e4a52-f061-4960-8246-e1560627336a/issues",
+                "url": "https://api.mythx.io/v1/analyses/<uuid>/issues",
                 "payload": "",
                 "params": {}
             }
@@ -133,7 +131,15 @@ def send_request(request_data: Dict, auth_header: Dict[str, str] = None) -> str:
                     response.status_code, response.content.decode()
                 )
             )
-        return response.text
+        try:
+            content = response.json()
+        except JSONDecodeError:
+            raise MythXAPIError(
+                "Got unexpected response data: Expected JSON but got {}".format(
+                    response.text
+                )
+            )
+        return content
 
     def execute_request_middlewares(self, req: Dict) -> Dict:
         """Sequentially execute the registered request middlewares.
@@ -157,7 +163,7 @@ def execute_request_middlewares(self, req: Dict) -> Dict:
             req = mw.process_request(req)
         return req
 
-    def execute_response_middlewares(self, resp: Type[BaseResponse]) -> Dict:
+    def execute_response_middlewares(self, resp: RESPONSE_MODELS) -> RESPONSE_MODELS:
         """Sequentially execute the registered response middlewares.
 
         Each middleware gets the serialized response domain model. On top of the request any
@@ -176,12 +182,12 @@ def execute_response_middlewares(self, resp: Type[BaseResponse]) -> Dict:
         """
         for mw in self.middlewares:
             LOGGER.debug("Executing response middleware: %s", mw)
-            resp = mw.process_response(resp)
+            resp = mw.process_response(resp=resp)
         return resp
 
     def parse_response(
-        self, resp: str, model: Type[BaseResponse]
-    ) -> Type[BaseResponse]:
+        self, resp: dict, model_cls: Type[RESPONSE_MODELS]
+    ) -> RESPONSE_MODELS:
         """Parse the API response into its respective domain model variant.
 
         This method takes the raw HTTP response and a class it should deserialize the responsse
@@ -192,13 +198,16 @@ def parse_response(
         on to the user.
 
         :param resp: The raw HTTP response JSON payload
-        :param model: The domain model class the data should be deserialized into
+        :param model_cls: The domain model class the data should be deserialized into
         :return: The domain model holding the response data
         """
-        m = model.from_json(resp)
+        if type(resp) is list and model_cls is DetectedIssuesResponse:
+            m = DetectedIssuesResponse(issue_reports=parse_obj_as(List[IssueReport], resp))
+        else:
+            m = model_cls(**resp)
         return self.execute_response_middlewares(m)
 
-    def assemble_request(self, req: Type[BaseRequest]) -> Dict:
+    def assemble_request(self, req: REQUEST_MODELS) -> Dict:
         """Assemble a request that is later sent to the API.
 
         This method generates an intermediate data dictionary format holding all the relevant

pythx/middleware/analysiscache.py

@@ -2,9 +2,9 @@
 field."""
 
 import logging
-from typing import Dict, Type
+from typing import Type
 
-from mythx_models.response.base import BaseResponse
+from pythx.types import RESPONSE_MODELS, REQUEST_MODELS
 
 from pythx.middleware.base import BaseMiddleware
 
@@ -23,7 +23,7 @@ def __init__(self, no_cache: bool = False):
         LOGGER.debug("Initializing with no_cache=%s", no_cache)
         self.no_cache = no_cache
 
-    def process_request(self, req: Dict) -> Dict:
+    def process_request(self, req: REQUEST_MODELS) -> REQUEST_MODELS:
         """Add the :code:`noCacheLookup` field if the request we are making is
         the submission of a new analysis job.
 
@@ -40,7 +40,7 @@ def process_request(self, req: Dict) -> Dict:
             req["payload"]["noCacheLookup"] = self.no_cache
         return req
 
-    def process_response(self, resp: Type[BaseResponse]) -> Type[BaseResponse]:
+    def process_response(self, resp: Type[RESPONSE_MODELS]) -> Type[RESPONSE_MODELS]:
         """This method is irrelevant for adding our tool name data, so we don't
         do anything here.