text: # -*- coding: utf-8 -*-
  import os
  import json
  import tccli.options_define as OptionsDefine
  import tccli.format_output as FormatOutput
  from tccli import __version__
  from tccli.utils import Utils
  from tccli.exceptions import ConfigurationError
  from tencentcloud.common import credential
  from tencentcloud.common.profile.http_profile import HttpProfile
  from tencentcloud.common.profile.client_profile import ClientProfile
  from tencentcloud.cwp.v20180228 import cwp_client as cwp_client_v20180228
  from tencentcloud.cwp.v20180228 import models as models_v20180228
  
  
  def doDeleteTags(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DeleteTagsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DeleteTags(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doTrustMalwares(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.TrustMalwaresRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.TrustMalwares(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeComponentStatistics(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeComponentStatisticsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeComponentStatistics(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDeleteMachineTag(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DeleteMachineTagRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DeleteMachineTag(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeLogStorageStatistic(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeLogStorageStatisticRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeLogStorageStatistic(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeAttackLogs(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeAttackLogsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeAttackLogs(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeSearchExportList(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeSearchExportListRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeSearchExportList(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeWeeklyReportMalwares(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeWeeklyReportMalwaresRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeWeeklyReportMalwares(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDeleteSearchTemplate(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DeleteSearchTemplateRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DeleteSearchTemplate(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doEditBashRule(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.EditBashRuleRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.EditBashRule(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDeleteUsualLoginPlaces(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DeleteUsualLoginPlacesRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DeleteUsualLoginPlaces(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeVuls(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeVulsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeVuls(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doMisAlarmNonlocalLoginPlaces(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.MisAlarmNonlocalLoginPlacesRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.MisAlarmNonlocalLoginPlaces(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doCreateBaselineStrategy(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.CreateBaselineStrategyRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.CreateBaselineStrategy(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeImportMachineInfo(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeImportMachineInfoRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeImportMachineInfo(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeBashRules(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeBashRulesRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeBashRules(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeSearchLogs(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeSearchLogsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeSearchLogs(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDeletePrivilegeEvents(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DeletePrivilegeEventsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DeletePrivilegeEvents(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doRenewProVersion(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.RenewProVersionRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.RenewProVersion(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doExportAttackLogs(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ExportAttackLogsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.ExportAttackLogs(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeUsualLoginPlaces(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeUsualLoginPlacesRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeUsualLoginPlaces(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDeleteBashEvents(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DeleteBashEventsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DeleteBashEvents(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDeleteMaliciousRequests(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DeleteMaliciousRequestsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DeleteMaliciousRequests(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeIndexList(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeIndexListRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeIndexList(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeReverseShellRules(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeReverseShellRulesRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeReverseShellRules(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doExportTasks(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ExportTasksRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.ExportTasks(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doRecoverMalwares(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.RecoverMalwaresRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.RecoverMalwares(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDeleteReverseShellRules(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DeleteReverseShellRulesRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DeleteReverseShellRules(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeHistoryService(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeHistoryServiceRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeHistoryService(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDeleteBruteAttacks(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DeleteBruteAttacksRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DeleteBruteAttacks(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doExportBashEvents(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ExportBashEventsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.ExportBashEvents(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doCreateProcessTask(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.CreateProcessTaskRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.CreateProcessTask(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doExportAssetCoreModuleList(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ExportAssetCoreModuleListRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.ExportAssetCoreModuleList(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeProcesses(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeProcessesRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeProcesses(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doSyncAssetScan(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.SyncAssetScanRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.SyncAssetScan(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeMalwares(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeMalwaresRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeMalwares(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeESAggregations(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeESAggregationsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeESAggregations(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doCreateSearchLog(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.CreateSearchLogRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.CreateSearchLog(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doModifyLoginWhiteList(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ModifyLoginWhiteListRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.ModifyLoginWhiteList(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribePrivilegeRules(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribePrivilegeRulesRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribePrivilegeRules(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doUntrustMaliciousRequest(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.UntrustMaliciousRequestRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.UntrustMaliciousRequest(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeImpactedHosts(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeImpactedHostsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeImpactedHosts(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDeleteNonlocalLoginPlaces(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DeleteNonlocalLoginPlacesRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DeleteNonlocalLoginPlaces(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeOpenPorts(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeOpenPortsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeOpenPorts(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doExportMaliciousRequests(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ExportMaliciousRequestsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.ExportMaliciousRequests(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeTagMachines(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeTagMachinesRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeTagMachines(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeNonlocalLoginPlaces(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeNonlocalLoginPlacesRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeNonlocalLoginPlaces(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doExportPrivilegeEvents(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ExportPrivilegeEventsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.ExportPrivilegeEvents(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeOverviewStatistics(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeOverviewStatisticsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeOverviewStatistics(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeVulInfo(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeVulInfoRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeVulInfo(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeComponents(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeComponentsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeComponents(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doCreateSearchTemplate(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.CreateSearchTemplateRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.CreateSearchTemplate(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeOpenPortTaskStatus(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeOpenPortTaskStatusRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeOpenPortTaskStatus(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeSecurityDynamics(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeSecurityDynamicsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeSecurityDynamics(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDeleteReverseShellEvents(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DeleteReverseShellEventsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DeleteReverseShellEvents(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDeletePrivilegeRules(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DeletePrivilegeRulesRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DeletePrivilegeRules(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDeleteMalwares(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DeleteMalwaresRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DeleteMalwares(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeMachineList(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeMachineListRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeMachineList(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeWeeklyReportNonlocalLoginPlaces(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeWeeklyReportNonlocalLoginPlacesRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeWeeklyReportNonlocalLoginPlaces(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeScanMalwareSchedule(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeScanMalwareScheduleRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeScanMalwareSchedule(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDeleteLoginWhiteList(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DeleteLoginWhiteListRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DeleteLoginWhiteList(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doCreateOpenPortTask(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.CreateOpenPortTaskRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.CreateOpenPortTask(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doCloseProVersion(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.CloseProVersionRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.CloseProVersion(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeAccountStatistics(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeAccountStatisticsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeAccountStatistics(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeExportMachines(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeExportMachinesRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeExportMachines(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doEditTags(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.EditTagsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.EditTags(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeOpenPortStatistics(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeOpenPortStatisticsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeOpenPortStatistics(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doExportBruteAttacks(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ExportBruteAttacksRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.ExportBruteAttacks(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doTrustMaliciousRequest(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.TrustMaliciousRequestRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.TrustMaliciousRequest(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doSwitchBashRules(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.SwitchBashRulesRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.SwitchBashRules(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doEditPrivilegeRule(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.EditPrivilegeRuleRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.EditPrivilegeRule(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doExportMalwares(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ExportMalwaresRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.ExportMalwares(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeBruteAttacks(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeBruteAttacksRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeBruteAttacks(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeBruteAttackList(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeBruteAttackListRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeBruteAttackList(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doModifyWebPageProtectSetting(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ModifyWebPageProtectSettingRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.ModifyWebPageProtectSetting(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doOpenProVersionPrepaid(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.OpenProVersionPrepaidRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.OpenProVersionPrepaid(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doAddMachineTag(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.AddMachineTagRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.AddMachineTag(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeSearchTemplates(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeSearchTemplatesRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeSearchTemplates(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doEditReverseShellRule(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.EditReverseShellRuleRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.EditReverseShellRule(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doModifyAlarmAttribute(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ModifyAlarmAttributeRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.ModifyAlarmAttribute(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doSeparateMalwares(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.SeparateMalwaresRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.SeparateMalwares(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doAddLoginWhiteList(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.AddLoginWhiteListRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.AddLoginWhiteList(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeProcessStatistics(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeProcessStatisticsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeProcessStatistics(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeMalwareInfo(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeMalwareInfoRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeMalwareInfo(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeMaliciousRequests(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeMaliciousRequestsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeMaliciousRequests(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDeleteBashRules(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DeleteBashRulesRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DeleteBashRules(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeReverseShellEvents(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeReverseShellEventsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeReverseShellEvents(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doModifyAutoOpenProVersionConfig(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ModifyAutoOpenProVersionConfigRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.ModifyAutoOpenProVersionConfig(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDeleteWebPageEventLog(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DeleteWebPageEventLogRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DeleteWebPageEventLog(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeAssetRecentMachineInfo(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeAssetRecentMachineInfoRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeAssetRecentMachineInfo(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeAgentVuls(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeAgentVulsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeAgentVuls(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeAccounts(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeAccountsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeAccounts(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeWeeklyReports(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeWeeklyReportsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeWeeklyReports(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeProVersionInfo(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeProVersionInfoRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeProVersionInfo(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeESHits(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeESHitsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeESHits(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeWebPageGeneralize(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeWebPageGeneralizeRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeWebPageGeneralize(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeSecurityEventsCnt(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeSecurityEventsCntRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeSecurityEventsCnt(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribePrivilegeEvents(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribePrivilegeEventsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribePrivilegeEvents(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeMachineInfo(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeMachineInfoRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeMachineInfo(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeAlarmAttribute(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeAlarmAttributeRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeAlarmAttribute(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doScanVul(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ScanVulRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.ScanVul(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeAttackVulTypeList(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeAttackVulTypeListRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeAttackVulTypeList(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeLoginWhiteList(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeLoginWhiteListRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeLoginWhiteList(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doUpdateBaselineStrategy(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.UpdateBaselineStrategyRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.UpdateBaselineStrategy(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeVulScanResult(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeVulScanResultRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeVulScanResult(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeMachineRegions(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeMachineRegionsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeMachineRegions(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeRiskDnsList(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeRiskDnsListRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeRiskDnsList(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeHistoryAccounts(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeHistoryAccountsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeHistoryAccounts(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doCreateProtectServer(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.CreateProtectServerRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.CreateProtectServer(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doExportNonlocalLoginPlaces(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ExportNonlocalLoginPlacesRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.ExportNonlocalLoginPlaces(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeWeeklyReportBruteAttacks(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeWeeklyReportBruteAttacksRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeWeeklyReportBruteAttacks(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doUntrustMalwares(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.UntrustMalwaresRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.UntrustMalwares(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doOpenProVersion(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.OpenProVersionRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.OpenProVersion(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeWeeklyReportVuls(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeWeeklyReportVulsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeWeeklyReportVuls(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeMachineOsList(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeMachineOsListRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeMachineOsList(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doModifyMalwareTimingScanSettings(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ModifyMalwareTimingScanSettingsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.ModifyMalwareTimingScanSettings(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeComponentInfo(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeComponentInfoRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeComponentInfo(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doModifyProVersionRenewFlag(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ModifyProVersionRenewFlagRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.ModifyProVersionRenewFlag(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeGeneralStat(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeGeneralStatRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeGeneralStat(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doSetBashEventsStatus(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.SetBashEventsStatusRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.SetBashEventsStatus(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doExportReverseShellEvents(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ExportReverseShellEventsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.ExportReverseShellEvents(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDeleteAttackLogs(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DeleteAttackLogsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DeleteAttackLogs(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDeleteMachine(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DeleteMachineRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DeleteMachine(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeProcessTaskStatus(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeProcessTaskStatusRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeProcessTaskStatus(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doRescanImpactedHost(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.RescanImpactedHostRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.RescanImpactedHost(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeTags(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeTagsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeTags(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeSecurityTrends(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeSecurityTrendsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeSecurityTrends(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeWeeklyReportInfo(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeWeeklyReportInfoRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeWeeklyReportInfo(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeAttackLogInfo(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeAttackLogInfoRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeAttackLogInfo(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeAssetInfo(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeAssetInfoRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeAssetInfo(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doIgnoreImpactedHosts(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.IgnoreImpactedHostsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.IgnoreImpactedHosts(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doExportVulDetectionExcel(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ExportVulDetectionExcelRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.ExportVulDetectionExcel(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeBashEvents(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeBashEventsRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeBashEvents(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doDescribeMachines(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.DescribeMachinesRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.DescribeMachines(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doCreateUsualLoginPlaces(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.CreateUsualLoginPlacesRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.CreateUsualLoginPlaces(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doExportVulDetectionReport(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.ExportVulDetectionReportRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.ExportVulDetectionReport(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  def doInquiryPriceOpenProVersionPrepaid(args, parsed_globals):
      g_param = parse_global_arg(parsed_globals)
  
      cred = credential.Credential(
          g_param[OptionsDefine.SecretId], g_param[OptionsDefine.SecretKey], g_param[OptionsDefine.Token]
      )
      http_profile = HttpProfile(
          reqTimeout=60 if g_param[OptionsDefine.Timeout] is None else int(g_param[OptionsDefine.Timeout]),
          reqMethod="POST",
          endpoint=g_param[OptionsDefine.Endpoint]
      )
      profile = ClientProfile(httpProfile=http_profile, signMethod="HmacSHA256")
      mod = CLIENT_MAP[g_param[OptionsDefine.Version]]
      client = mod.CwpClient(cred, g_param[OptionsDefine.Region], profile)
      client._sdkVersion += ("_CLI_" + __version__)
      models = MODELS_MAP[g_param[OptionsDefine.Version]]
      model = models.InquiryPriceOpenProVersionPrepaidRequest()
      model.from_json_string(json.dumps(args))
      rsp = client.InquiryPriceOpenProVersionPrepaid(model)
      result = rsp.to_json_string()
      try:
          json_obj = json.loads(result)
      except TypeError as e:
          json_obj = json.loads(result.decode('utf-8'))  # python3.3
      FormatOutput.output("action", json_obj, g_param[OptionsDefine.Output], g_param[OptionsDefine.Filter])
  
  
  CLIENT_MAP = {
      "v20180228": cwp_client_v20180228,
  
  }
  
  MODELS_MAP = {
      "v20180228": models_v20180228,
  
  }
  
  ACTION_MAP = {
      "DeleteTags": doDeleteTags,
      "TrustMalwares": doTrustMalwares,
      "DescribeComponentStatistics": doDescribeComponentStatistics,
      "DeleteMachineTag": doDeleteMachineTag,
      "DescribeLogStorageStatistic": doDescribeLogStorageStatistic,
      "DescribeAttackLogs": doDescribeAttackLogs,
      "DescribeSearchExportList": doDescribeSearchExportList,
      "DescribeWeeklyReportMalwares": doDescribeWeeklyReportMalwares,
      "DeleteSearchTemplate": doDeleteSearchTemplate,
      "EditBashRule": doEditBashRule,
      "DeleteUsualLoginPlaces": doDeleteUsualLoginPlaces,
      "DescribeVuls": doDescribeVuls,
      "MisAlarmNonlocalLoginPlaces": doMisAlarmNonlocalLoginPlaces,
      "CreateBaselineStrategy": doCreateBaselineStrategy,
      "DescribeImportMachineInfo": doDescribeImportMachineInfo,
      "DescribeBashRules": doDescribeBashRules,
      "DescribeSearchLogs": doDescribeSearchLogs,
      "DeletePrivilegeEvents": doDeletePrivilegeEvents,
      "RenewProVersion": doRenewProVersion,
      "ExportAttackLogs": doExportAttackLogs,
      "DescribeUsualLoginPlaces": doDescribeUsualLoginPlaces,
      "DeleteBashEvents": doDeleteBashEvents,
      "DeleteMaliciousRequests": doDeleteMaliciousRequests,
      "DescribeIndexList": doDescribeIndexList,
      "DescribeReverseShellRules": doDescribeReverseShellRules,
      "ExportTasks": doExportTasks,
      "RecoverMalwares": doRecoverMalwares,
      "DeleteReverseShellRules": doDeleteReverseShellRules,
      "DescribeHistoryService": doDescribeHistoryService,
      "DeleteBruteAttacks": doDeleteBruteAttacks,
      "ExportBashEvents": doExportBashEvents,
      "CreateProcessTask": doCreateProcessTask,
      "ExportAssetCoreModuleList": doExportAssetCoreModuleList,
      "DescribeProcesses": doDescribeProcesses,
      "SyncAssetScan": doSyncAssetScan,
      "DescribeMalwares": doDescribeMalwares,
      "DescribeESAggregations": doDescribeESAggregations,
      "CreateSearchLog": doCreateSearchLog,
      "ModifyLoginWhiteList": doModifyLoginWhiteList,
      "DescribePrivilegeRules": doDescribePrivilegeRules,
      "UntrustMaliciousRequest": doUntrustMaliciousRequest,
      "DescribeImpactedHosts": doDescribeImpactedHosts,
      "DeleteNonlocalLoginPlaces": doDeleteNonlocalLoginPlaces,
      "DescribeOpenPorts": doDescribeOpenPorts,
      "ExportMaliciousRequests": doExportMaliciousRequests,
      "DescribeTagMachines": doDescribeTagMachines,
      "DescribeNonlocalLoginPlaces": doDescribeNonlocalLoginPlaces,
      "ExportPrivilegeEvents": doExportPrivilegeEvents,
      "DescribeOverviewStatistics": doDescribeOverviewStatistics,
      "DescribeVulInfo": doDescribeVulInfo,
      "DescribeComponents": doDescribeComponents,
      "CreateSearchTemplate": doCreateSearchTemplate,
      "DescribeOpenPortTaskStatus": doDescribeOpenPortTaskStatus,
      "DescribeSecurityDynamics": doDescribeSecurityDynamics,
      "DeleteReverseShellEvents": doDeleteReverseShellEvents,
      "DeletePrivilegeRules": doDeletePrivilegeRules,
      "DeleteMalwares": doDeleteMalwares,
      "DescribeMachineList": doDescribeMachineList,
      "DescribeWeeklyReportNonlocalLoginPlaces": doDescribeWeeklyReportNonlocalLoginPlaces,
      "DescribeScanMalwareSchedule": doDescribeScanMalwareSchedule,
      "DeleteLoginWhiteList": doDeleteLoginWhiteList,
      "CreateOpenPortTask": doCreateOpenPortTask,
      "CloseProVersion": doCloseProVersion,
      "DescribeAccountStatistics": doDescribeAccountStatistics,
      "DescribeExportMachines": doDescribeExportMachines,
      "EditTags": doEditTags,
      "DescribeOpenPortStatistics": doDescribeOpenPortStatistics,
      "ExportBruteAttacks": doExportBruteAttacks,
      "TrustMaliciousRequest": doTrustMaliciousRequest,
      "SwitchBashRules": doSwitchBashRules,
      "EditPrivilegeRule": doEditPrivilegeRule,
      "ExportMalwares": doExportMalwares,
      "DescribeBruteAttacks": doDescribeBruteAttacks,
      "DescribeBruteAttackList": doDescribeBruteAttackList,
      "ModifyWebPageProtectSetting": doModifyWebPageProtectSetting,
      "OpenProVersionPrepaid": doOpenProVersionPrepaid,
      "AddMachineTag": doAddMachineTag,
      "DescribeSearchTemplates": doDescribeSearchTemplates,
      "EditReverseShellRule": doEditReverseShellRule,
      "ModifyAlarmAttribute": doModifyAlarmAttribute,
      "SeparateMalwares": doSeparateMalwares,
      "AddLoginWhiteList": doAddLoginWhiteList,
      "DescribeProcessStatistics": doDescribeProcessStatistics,
      "DescribeMalwareInfo": doDescribeMalwareInfo,
      "DescribeMaliciousRequests": doDescribeMaliciousRequests,
      "DeleteBashRules": doDeleteBashRules,
      "DescribeReverseShellEvents": doDescribeReverseShellEvents,
      "ModifyAutoOpenProVersionConfig": doModifyAutoOpenProVersionConfig,
      "DeleteWebPageEventLog": doDeleteWebPageEventLog,
      "DescribeAssetRecentMachineInfo": doDescribeAssetRecentMachineInfo,
      "DescribeAgentVuls": doDescribeAgentVuls,
      "DescribeAccounts": doDescribeAccounts,
      "DescribeWeeklyReports": doDescribeWeeklyReports,
      "DescribeProVersionInfo": doDescribeProVersionInfo,
      "DescribeESHits": doDescribeESHits,
      "DescribeWebPageGeneralize": doDescribeWebPageGeneralize,
      "DescribeSecurityEventsCnt": doDescribeSecurityEventsCnt,
      "DescribePrivilegeEvents": doDescribePrivilegeEvents,
      "DescribeMachineInfo": doDescribeMachineInfo,
      "DescribeAlarmAttribute": doDescribeAlarmAttribute,
      "ScanVul": doScanVul,
      "DescribeAttackVulTypeList": doDescribeAttackVulTypeList,
      "DescribeLoginWhiteList": doDescribeLoginWhiteList,
      "UpdateBaselineStrategy": doUpdateBaselineStrategy,
      "DescribeVulScanResult": doDescribeVulScanResult,
      "DescribeMachineRegions": doDescribeMachineRegions,
      "DescribeRiskDnsList": doDescribeRiskDnsList,
      "DescribeHistoryAccounts": doDescribeHistoryAccounts,
      "CreateProtectServer": doCreateProtectServer,
      "ExportNonlocalLoginPlaces": doExportNonlocalLoginPlaces,
      "DescribeWeeklyReportBruteAttacks": doDescribeWeeklyReportBruteAttacks,
      "UntrustMalwares": doUntrustMalwares,
      "OpenProVersion": doOpenProVersion,
      "DescribeWeeklyReportVuls": doDescribeWeeklyReportVuls,
      "DescribeMachineOsList": doDescribeMachineOsList,
      "ModifyMalwareTimingScanSettings": doModifyMalwareTimingScanSettings,
      "DescribeComponentInfo": doDescribeComponentInfo,
      "ModifyProVersionRenewFlag": doModifyProVersionRenewFlag,
      "DescribeGeneralStat": doDescribeGeneralStat,
      "SetBashEventsStatus": doSetBashEventsStatus,
      "ExportReverseShellEvents": doExportReverseShellEvents,
      "DeleteAttackLogs": doDeleteAttackLogs,
      "DeleteMachine": doDeleteMachine,
      "DescribeProcessTaskStatus": doDescribeProcessTaskStatus,
      "RescanImpactedHost": doRescanImpactedHost,
      "DescribeTags": doDescribeTags,
      "DescribeSecurityTrends": doDescribeSecurityTrends,
      "DescribeWeeklyReportInfo": doDescribeWeeklyReportInfo,
      "DescribeAttackLogInfo": doDescribeAttackLogInfo,
      "DescribeAssetInfo": doDescribeAssetInfo,
      "IgnoreImpactedHosts": doIgnoreImpactedHosts,
      "ExportVulDetectionExcel": doExportVulDetectionExcel,
      "DescribeBashEvents": doDescribeBashEvents,
      "DescribeMachines": doDescribeMachines,
      "CreateUsualLoginPlaces": doCreateUsualLoginPlaces,
      "ExportVulDetectionReport": doExportVulDetectionReport,
      "InquiryPriceOpenProVersionPrepaid": doInquiryPriceOpenProVersionPrepaid,
  
  }
  
  AVAILABLE_VERSION_LIST = [
      "v20180228",
  
  ]
  
  
  def action_caller():
      return ACTION_MAP
  
  
  def parse_global_arg(parsed_globals):
      g_param = parsed_globals
  
      is_exist_profile = True
      if not parsed_globals["profile"]:
          is_exist_profile = False
          g_param["profile"] = "default"
  
      configure_path = os.path.join(os.path.expanduser("~"), ".tccli")
      is_conf_exist, conf_path = Utils.file_existed(configure_path, g_param["profile"] + ".configure")
      is_cred_exist, cred_path = Utils.file_existed(configure_path, g_param["profile"] + ".credential")
  
      conf = {}
      cred = {}
  
      if is_conf_exist:
          conf = Utils.load_json_msg(conf_path)
      if is_cred_exist:
          cred = Utils.load_json_msg(cred_path)
  
      if not (isinstance(conf, dict) and isinstance(cred, dict)):
          raise ConfigurationError(
              "file: %s or %s is not json format"
              % (g_param["profile"] + ".configure", g_param["profile"] + ".credential"))
  
      if OptionsDefine.Token not in cred:
          cred[OptionsDefine.Token] = None
  
      if not is_exist_profile:
          if os.environ.get(OptionsDefine.ENV_SECRET_ID) and os.environ.get(OptionsDefine.ENV_SECRET_KEY):
              cred[OptionsDefine.SecretId] = os.environ.get(OptionsDefine.ENV_SECRET_ID)
              cred[OptionsDefine.SecretKey] = os.environ.get(OptionsDefine.ENV_SECRET_KEY)
              cred[OptionsDefine.Token] = os.environ.get(OptionsDefine.ENV_TOKEN)
  
          if os.environ.get(OptionsDefine.ENV_REGION):
              conf[OptionsDefine.Region] = os.environ.get(OptionsDefine.ENV_REGION)
  
      for param in g_param.keys():
          if g_param[param] is None:
              if param in [OptionsDefine.SecretKey, OptionsDefine.SecretId, OptionsDefine.Token]:
                  if param in cred:
                      g_param[param] = cred[param]
                  else:
                      raise ConfigurationError("%s is invalid" % param)
              elif param in [OptionsDefine.Region, OptionsDefine.Output]:
                  if param in conf:
                      g_param[param] = conf[param]
                  else:
                      raise ConfigurationError("%s is invalid" % param)
  
      try:
          if g_param[OptionsDefine.ServiceVersion]:
              g_param[OptionsDefine.Version] = "v" + g_param[OptionsDefine.ServiceVersion].replace('-', '')
          else:
              version = conf["cwp"][OptionsDefine.Version]
              g_param[OptionsDefine.Version] = "v" + version.replace('-', '')
  
          if g_param[OptionsDefine.Endpoint] is None:
              g_param[OptionsDefine.Endpoint] = conf["cwp"][OptionsDefine.Endpoint]
      except Exception as err:
          raise ConfigurationError("config file:%s error, %s" % (conf_path, str(err)))
  
      if g_param[OptionsDefine.Version] not in AVAILABLE_VERSION_LIST:
          raise Exception("available versions: %s" % " ".join(AVAILABLE_VERSION_LIST))
  
      return g_param
  
  