Merge pull request #24 from tjarrettveracode/tjarrettveracode/issue23

Tjarrettveracode/issue23

veracode_api_py/api.py

@@ -82,65 +82,65 @@ def status(self):
     def get_apps(self):
         return Applications().get_all()
 
-    def get_app (self,guid=None,legacy_id=None):
+    def get_app (self,guid: UUID=None,legacy_id=None):
         return Applications().get(guid,legacy_id)
 
     def get_app_by_name (self,appname):
         return Applications().get_by_name(appname)
 
-    def create_app(self,app_name,business_criticality, business_unit=None, teams=[]):
+    def create_app(self,app_name,business_criticality, business_unit: UUID=None, teams=[]):
         return Applications().create(app_name,business_criticality,business_unit,teams)
 
-    def delete_app (self,guid):
+    def delete_app (self,guid: UUID):
         return Applications().delete(guid)
 
     def get_custom_fields (self):
         return CustomFields().get_all()
 
-    def get_app_sandboxes (self,guid):
+    def get_app_sandboxes (self,guid: UUID):
         return Sandboxes().get_all(guid)
 
-    def create_sandbox (self, app, name, auto_recreate=False, custom_fields=[]):
+    def create_sandbox (self, app: UUID, name, auto_recreate=False, custom_fields=[]):
         return Sandboxes().create(app,name,auto_recreate,custom_fields)
 
-    def update_sandbox (self, app, sandbox, name, auto_recreate=False, custom_fields=[]):
+    def update_sandbox (self, app: UUID, sandbox: UUID, name, auto_recreate=False, custom_fields=[]):
         return Sandboxes().update(app,sandbox,name,auto_recreate,custom_fields)
 
-    def delete_sandbox (self, app, sandbox):
+    def delete_sandbox (self, app: UUID, sandbox: UUID):
         return Sandboxes().delete(app,sandbox)
 
     # Policy APIs
 
     def get_policies (self):
         return Policies().get_all()
 
-    def get_policy (self,guid):
+    def get_policy (self,guid: UUID):
         return Policies().get(guid)
 
     def create_policy(self, name, description, vendor_policy=False, finding_rules=[], scan_frequency_rules=[], grace_periods={}):
         return Policies().create(name, description, vendor_policy, finding_rules, scan_frequency_rules, grace_periods)
 
-    def delete_policy (self,guid):
+    def delete_policy (self,guid: UUID):
         return Policies().delete(guid)
 
-    def update_policy(self, guid, name, description, vendor_policy=False, finding_rules=[], scan_frequency_rules=[], grace_periods={}):
+    def update_policy(self, guid: UUID, name, description, vendor_policy=False, finding_rules=[], scan_frequency_rules=[], grace_periods={}):
         return Policies().update(guid, name, description, vendor_policy, finding_rules, scan_frequency_rules, grace_periods)
 
     # Findings and Reporting APIs
 
-    def get_findings(self,app,scantype='STATIC',annot='TRUE',request_params=None,sandbox=None):
+    def get_findings(self,app: UUID,scantype='STATIC',annot='TRUE',request_params=None,sandbox: UUID=None):
         return Findings().get_findings(app,scantype,annot,request_params,sandbox)
 
-    def get_static_flaw_info(self,app,issueid,sandbox=None):
+    def get_static_flaw_info(self,app: UUID,issueid,sandbox: UUID=None):
         return Findings().get_static_flaw_info(app,issueid,sandbox)
 
-    def get_dynamic_flaw_info(self,app,issueid):
+    def get_dynamic_flaw_info(self,app: UUID,issueid):
         return Findings().get_dynamic_flaw_info(app,issueid)
 
-    def get_summary_report(self,app,sandbox=None):
+    def get_summary_report(self,app: UUID,sandbox=None):
         return SummaryReport().get_summary_report(app,sandbox)
 
-    def add_annotation(self,app,issue_list,comment,action,sandbox=None):
+    def add_annotation(self,app: UUID,issue_list,comment,action,sandbox: UUID=None):
         return Findings().add_annotation(app,issue_list,comment,action,sandbox)
 
     def match_findings(self,origin_finding,potential_matches,approved_findings_only=True):
@@ -160,19 +160,19 @@ def get_collections_by_business_unit(self,business_unit_name):
     def get_collections_statistics(self):
         return Collections().get_statistics()
 
-    def get_collection(self,guid):
+    def get_collection(self,guid: UUID):
         return Collections().get(guid)
 
-    def get_collection_assets(self,guid):
+    def get_collection_assets(self,guid: UUID):
         return Collections().get_assets(guid)
 
-    def create_collection(self,name,description="",tags='',business_unit_guid=None,custom_fields=[],assets=[]):
+    def create_collection(self,name,description="",tags='',business_unit_guid: UUID=None,custom_fields=[],assets=[]):
         return Collections().create(name,description,tags,business_unit_guid,custom_fields,assets)
 
-    def update_collection(self,guid,name,description="",tags="",business_unit_guid=None,custom_fields=[],assets=[]):
+    def update_collection(self,guid,name,description="",tags="",business_unit_guid: UUID=None,custom_fields=[],assets=[]):
         return Collections().update(guid,name,description,tags,business_unit_guid,custom_fields,assets)
 
-    def delete_collection(self,guid):
+    def delete_collection(self,guid: UUID):
         return Collections().delete(guid)
 
     ## Identity APIs
@@ -183,61 +183,61 @@ def get_users(self):
     def get_user_self (self):
         return Users().get_self()
 
-    def get_user(self,user_guid):
+    def get_user(self,user_guid: UUID):
         return Users().get(user_guid)
 
     def get_user_by_name(self,username):
         return Users().get_by_name(username)
 
-    def get_user_by_search(self, search_term=None, api_id=None, role_id=None, login_status=None, saml_user=None, team_id=None, detailed=False, user_type=None, request_params=None):
+    def get_user_by_search(self, search_term=None, api_id: UUID=None, role_id: UUID=None, login_status=None, saml_user=None, team_id: UUID=None, detailed=False, user_type=None, request_params=None):
         return Users().get_user_search(search_term,api_id,role_id,login_status,saml_user,team_id,detailed,user_type,request_params)
 
     def create_user (self,email,firstname,lastname,username=None,type="HUMAN",roles=[],teams=[],mfa=False):
         return Users().create(email,firstname,lastname,username,type,roles,teams,mfa=mfa)
 
-    def update_user_roles (self,user_guid,roles):
+    def update_user_roles (self,user_guid: UUID,roles):
         return Users().update_roles(user_guid,roles)
 
-    def update_user (self,user_guid,changes):
+    def update_user (self,user_guid: UUID,changes):
         return Users().update(user_guid,changes)
 
-    def update_user_email_address (self,user_guid,email_address,ignore_verification=False):
+    def update_user_email_address (self,user_guid: UUID,email_address,ignore_verification=False):
         return Users().update_email_address(user_guid,email_address,ignore_verification)
 
     def send_password_reset (self,user_legacy_id):
         return Users().reset_password(user_legacy_id)
 
-    def disable_user (self,user_guid):
+    def disable_user (self,user_guid: UUID):
         return Users().disable(user_guid)
 
-    def delete_user (self,user_guid):
+    def delete_user (self,user_guid: UUID):
         return Users().delete(user_guid)
 
     def get_teams (self, all_for_org=False):
         return Teams().get_all(all_for_org)
 
-    def create_team (self, team_name, business_unit=None, members=[]):        
+    def create_team (self, team_name, business_unit: UUID=None, members=[]):        
         return Teams().create(team_name,business_unit,members)
 
-    def update_team (self, team_guid, team_name="", business_unit=None, members=[]):
+    def update_team (self, team_guid: UUID, team_name="", business_unit: UUID=None, members=[]):
         return Teams().update(team_guid,team_name,business_unit,members)
 
-    def delete_team (self, team_guid):
+    def delete_team (self, team_guid: UUID):
         return Teams().delete(team_guid)
 
     def get_business_units (self):
         return BusinessUnits().get_all()
 
-    def get_business_unit (self, guid):
+    def get_business_unit (self, guid: UUID):
         return BusinessUnits().get(guid)
 
     def create_business_unit (self, name, teams=[]):
         return BusinessUnits().create(name,teams)
 
-    def update_business_unit (self, guid, name='', teams=[]):
+    def update_business_unit (self, guid: UUID, name='', teams=[]):
         return BusinessUnits().update(guid,name,teams)
 
-    def delete_business_unit (self, guid):
+    def delete_business_unit (self, guid: UUID):
         return BusinessUnits().delete(guid)
 
     def get_creds (self,api_id=None):
@@ -349,85 +349,85 @@ def get_analyses_by_target_url(self,url):
     def get_analyses_by_search_term(self,search_term):
         return Analyses().get_by_search_term(search_term=search_term)
 
-    def get_analysis(self,analysis_id):
+    def get_analysis(self,analysis_id: UUID):
         return Analyses().get(guid=analysis_id)
 
-    def get_analysis_audits(self,analysis_id):
+    def get_analysis_audits(self,analysis_id: UUID):
         return Analyses().get_audits(guid=analysis_id)
 
-    def get_analysis_scans(self,analysis_id):
+    def get_analysis_scans(self,analysis_id: UUID):
         return Analyses().get_scans(guid=analysis_id)
 
-    def get_analysis_scanner_variables(self,analysis_id):
+    def get_analysis_scanner_variables(self,analysis_id: UUID):
         return Analyses().get_scanner_variables(guid=analysis_id)
 
-    def create_analysis(self,name,scans,business_unit_guid=None,email=None,owner=None):
+    def create_analysis(self,name,scans,business_unit_guid: UUID=None,email=None,owner=None):
         return Analyses().create(name,scans,business_unit_guid,email,owner)
 
-    def update_analysis(self,guid,name,scans,business_unit_guid=None,email=None,owner=None):
+    def update_analysis(self,guid: UUID,name,scans,business_unit_guid: UUID=None,email=None,owner=None):
         return Analyses().update(guid,name,scans,business_unit_guid,email,owner)
 
-    def update_analysis_scanner_variable(self,analysis_guid,scanner_variable_guid,reference_key,value,description):
+    def update_analysis_scanner_variable(self,analysis_guid: UUID,scanner_variable_guid: UUID,reference_key,value,description):
         return Analyses().update_scanner_variable(analysis_guid,scanner_variable_guid,reference_key,value,description)
 
-    def delete_analysis_scanner_variable(self,analysis_guid,scanner_variable_guid):
+    def delete_analysis_scanner_variable(self,analysis_guid: UUID,scanner_variable_guid: UUID):
         return Analyses().delete_scanner_variable(analysis_guid,scanner_variable_guid)
 
-    def delete_analysis(self,analysis_guid):
+    def delete_analysis(self,analysis_guid: UUID):
         return Analyses().delete(guid=analysis_guid)
 
-    def get_dyn_scan(self,scan_guid):
+    def get_dyn_scan(self,scan_guid: UUID):
         return Scans().get(guid=scan_guid)
 
-    def get_dyn_scan_audits(self,scan_guid):
+    def get_dyn_scan_audits(self,scan_guid: UUID):
         return Scans().get_audits(guid=scan_guid)
 
-    def get_dyn_scan_config(self,scan_guid):
+    def get_dyn_scan_config(self,scan_guid: UUID):
         return Scans().get_configuration(guid=scan_guid)
 
-    def update_dyn_scan(self,scan_guid,scan):
+    def update_dyn_scan(self,scan_guid: UUID,scan):
         return Scans().update(guid=scan_guid,scan=scan)
 
-    def delete_dyn_scan(self,scan_guid):
+    def delete_dyn_scan(self,scan_guid: UUID):
         return Scans().delete(guid=scan_guid)
 
-    def get_scan_scanner_variables(self,scan_id):
+    def get_scan_scanner_variables(self,scan_id: UUID):
         return Scans().get_scanner_variables(guid=scan_id)
 
-    def update_scan_scanner_variable(self,scan_guid,scanner_variable_guid,reference_key,value,description):
+    def update_scan_scanner_variable(self,scan_guid: UUID,scanner_variable_guid: UUID,reference_key,value,description):
         return Scans().update_scanner_variable(scan_guid,scanner_variable_guid,reference_key,value,description)
 
-    def delete_scan_scanner_variable(self,scan_guid,scanner_variable_guid):
+    def delete_scan_scanner_variable(self,scan_guid: UUID,scanner_variable_guid: UUID):
         return Scans().delete_scanner_variable(scan_guid,scanner_variable_guid)
 
     def get_analysis_occurrences(self):
         return Occurrences().get_all()
 
-    def get_analysis_occurrence(self,occurrence_guid):
+    def get_analysis_occurrence(self,occurrence_guid: UUID):
         return Occurrences().get(guid=occurrence_guid)
 
-    def stop_analysis_occurrence(self,occurrence_guid,save_or_delete):
+    def stop_analysis_occurrence(self,occurrence_guid: UUID,save_or_delete):
         return Occurrences().stop(guid=occurrence_guid,save_or_delete=save_or_delete)
 
-    def get_scan_occurrences(self,occurrence_guid):
+    def get_scan_occurrences(self,occurrence_guid: UUID):
         return Occurrences().get_scan_occurrences(guid=occurrence_guid)
 
-    def get_scan_occurrence(self,scan_occ_guid):
+    def get_scan_occurrence(self,scan_occ_guid: UUID):
         return ScanOccurrences().get(guid=scan_occ_guid)
 
-    def stop_scan_occurrence(self,scan_occ_guid,save_or_delete):
+    def stop_scan_occurrence(self,scan_occ_guid: UUID,save_or_delete):
         return ScanOccurrences().stop(guid=scan_occ_guid, save_or_delete=save_or_delete)
 
-    def get_scan_occurrence_configuration(self,scan_occ_guid):
+    def get_scan_occurrence_configuration(self,scan_occ_guid: UUID):
         return ScanOccurrences().get_configuration(guid=scan_occ_guid)
 
-    def get_scan_occurrence_verification_report(self,scan_occ_guid):
+    def get_scan_occurrence_verification_report(self,scan_occ_guid: UUID):
         return ScanOccurrences().get_verification_report(guid=scan_occ_guid)
 
-    def get_scan_occurrence_notes_report(self,scan_occ_guid):
+    def get_scan_occurrence_notes_report(self,scan_occ_guid: UUID):
         return ScanOccurrences().get_scan_notes_report(guid=scan_occ_guid)
 
-    def get_scan_occurrence_screenshots(self,scan_occ_guid):
+    def get_scan_occurrence_screenshots(self,scan_occ_guid: UUID):
         return ScanOccurrences().get_screenshots(guid=scan_occ_guid)
 
     def get_codegroups(self):
@@ -445,16 +445,16 @@ def get_dynamic_scan_capacity_summary(self):
     def get_global_scanner_variables(self):
         return ScannerVariables().get_all()
 
-    def get_global_scanner_variable(self,guid):
+    def get_global_scanner_variable(self,guid: UUID):
         return ScannerVariables().get(guid)
 
     def create_global_scanner_variable(self,reference_key,value,description):
         return ScannerVariables().create(reference_key,value,description)
 
-    def update_global_scanner_variable(self,guid,reference_key,value,description):
+    def update_global_scanner_variable(self,guid: UUID,reference_key,value,description):
         return ScannerVariables().update(guid,reference_key,value,description)
 
-    def delete_global_scanner_variable(self,guid):
+    def delete_global_scanner_variable(self,guid: UUID):
         return ScannerVariables().delete(guid)
 
     def dyn_setup_user_agent(self,custom_header,type):
@@ -493,5 +493,5 @@ def dyn_setup_auth_config(self,authentication_node:dict):
     def dyn_setup_scan_config_request(self, url, allowed_hosts:List, auth_config=None, crawl_config=None, scan_setting=None):
         return DynUtils().setup_scan_config_request(url,allowed_hosts,auth_config,crawl_config,scan_setting)
 
-    def dyn_setup_scan(self, scan_config_request, scan_contact_info=None, linked_app_guid=None):
+    def dyn_setup_scan(self, scan_config_request, scan_contact_info=None, linked_app_guid: UUID=None):
         return DynUtils().setup_scan(scan_config_request,scan_contact_info, linked_app_guid)

veracode_api_py/applications.py

@@ -2,6 +2,7 @@
 
 import json
 from urllib import parse
+from uuid import UUID
 
 from .apihelper import APIHelper
 
@@ -15,7 +16,7 @@ def get_all(self,policy_check_after=None):
         return APIHelper()._rest_paged_request('appsec/v1/applications',"GET", params=params, 
                                                 element="applications")
 
-    def get (self,guid=None,legacy_id=None):
+    def get (self,guid: UUID=None,legacy_id: int=None):
         """Gets a single applications in the current customer account using the Veracode Application API."""
         if legacy_id == None:
             apps_base_uri = "appsec/v1/applications" + "/{}"
@@ -26,22 +27,22 @@ def get (self,guid=None,legacy_id=None):
 
         return APIHelper()._rest_request(uri,"GET")
 
-    def get_by_name (self,appname):
+    def get_by_name (self,appname: str):
         """Gets a list of applications having a name that matches appname, using the Veracode Applications API."""
         params = {"name": parse.quote(appname)}
         return APIHelper()._rest_paged_request(uri="appsec/v1/applications",method="GET",element="applications",params=params)
 
-    def create(self,app_name,business_criticality, business_unit=None, teams=[]):
+    def create(self,app_name:str ,business_criticality, business_unit: UUID=None, teams=[]):
         return self._create_or_update("CREATE",app_name,business_criticality,business_unit,teams)
 
-    def update(self,guid,app_name,business_criticality, business_unit=None, teams=[]):
+    def update(self,guid: UUID,app_name:str ,business_criticality, business_unit: UUID=None, teams=[]):
         return self._create_or_update("UPDATE",app_name,business_criticality,business_unit,teams,guid)
 
-    def delete(self,guid):
+    def delete(self,guid: UUID):
         uri = 'appsec/v1/applications/{}'.format(guid)
         return APIHelper()._rest_request(uri,'DELETE')
 
-    def _create_or_update(self,method,app_name,business_criticality, business_unit=None, teams=[],guid=None):
+    def _create_or_update(self,method,app_name: str,business_criticality, business_unit: UUID=None, teams=[],guid=None):
         if method == 'CREATE':
             uri = 'appsec/v1/applications'
             httpmethod = 'POST'
@@ -68,12 +69,12 @@ def _create_or_update(self,method,app_name,business_criticality, business_unit=N
         return APIHelper()._rest_request(uri,httpmethod,body=payload)
 
 class Sandboxes ():
-    def get_all(self,guid):
+    def get_all(self,guid: UUID):
         request_params = {}
         uri = 'appsec/v1/applications/{}/sandboxes'.format(guid)
         return APIHelper()._rest_paged_request(uri,'GET','sandboxes',request_params)
 
-    def create(self, app, name, auto_recreate=False, custom_fields=[]):
+    def create(self, app: UUID, name: str, auto_recreate=False, custom_fields=[]):
         uri = 'appsec/v1/applications/{}/sandboxes'.format(app)
         sandbox_def = {'name': name, 'auto_recreate': auto_recreate}
 
@@ -83,7 +84,7 @@ def create(self, app, name, auto_recreate=False, custom_fields=[]):
         payload = json.dumps(sandbox_def)
         return APIHelper()._rest_request(uri,'POST',body=payload)
 
-    def update(self, app, sandbox, name, auto_recreate=False, custom_fields=[]):
+    def update(self, app: UUID, sandbox: UUID, name: str, auto_recreate=False, custom_fields=[]):
         uri = 'appsec/v1/applications/{}/sandboxes/{}'.format(app,sandbox)
         sandbox_def = {'name': name, 'auto_recreate': auto_recreate}
 
@@ -93,7 +94,7 @@ def update(self, app, sandbox, name, auto_recreate=False, custom_fields=[]):
         payload = json.dumps(sandbox_def)
         return APIHelper()._rest_request(uri,'PUT',body=payload)
 
-    def delete(self, app, sandbox):
+    def delete(self, app: UUID, sandbox: UUID):
         uri = 'appsec/v1/applications/{}/sandboxes/{}'.format(app,sandbox)
         return APIHelper()._rest_request(uri,'DELETE')