[[source]]

name = "pypi"

url = "https://pypi.org/simple"

verify_ssl = true

[dev-packages]

pylint = "*"

pytest = "==5.0.1"

pytest-mock = "*"

requests-mock = "*"

pytest-asyncio = "*"

[packages]

pytest = "*"

requests = "*"

[requires]

python_version = "3.7"

An integration to translate English to Yodish.

1. Navigate to **Settings** > **Integrations** > **Servers & Services**.

2. Search for YodaSpeak.

3. Click **Add instance** to create and configure a new integration instance.

| **Parameter** | **Description** | **Required** |

| --- | --- | --- |

| Base URL of the service | | True |

| API Key | The API Key to use for connection | False |

| Trust any certificate (not secure) | | False |

| Use system proxy settings | | False |

4. Click **Test** to validate the URLs, token, and connection.

You can execute these commands from the Cortex XSOAR CLI, as part of an automation, or in a playbook.

After you successfully execute a command, a DBot message appears in the War Room with the command details.

Use this command to translate English text.

| **Argument Name** | **Description** | **Required** |

| --- | --- | --- |

| text | The English text to translate. | Required |

| **Path** | **Type** | **Description** |

| --- | --- | --- |

| YodaSpeak.Translation | String | The translated text, in Yodish. |

| YodaSpeak.Original | String | The original \(English\) text we translated. |

|Original|Translation|

|---|---|

| this is some sentence for translation. | Some sentence for translation, this is. |

TRANSLATE_OUTPUT_PREFIX = 'Phrase'

requests.packages.urllib3.disable_warnings() # pylint: disable=no-member

class Client(BaseClient):

def __init__(self, api_key: str, base_url: str, proxy: bool, verify: bool):

super().__init__(base_url=base_url, proxy=proxy, verify=verify)

self.api_key = api_key

if self.api_key:

self._headers = {'X-Funtranslations-Api-Secret': self.api_key}

def translate(self, text: str):

return self._http_request(method='POST', url_suffix='yoda', data={'text': text}, resp_type='json',

ok_codes=(200,))

def test_module(client: Client) -> str:

"""

try:

response = client.translate('I have the high ground!')

success = demisto.get(response, 'success.total') # Safe access to response['success']['total']

if success != 1:

return f'Unexpected result from the service: success={success} (expected success=1)'

return 'ok'

except Exception as e:

exception_text = str(e).lower()

if 'forbidden' in exception_text or 'authorization' in exception_text:

return 'Authorization Error: make sure API Key is correctly set'

else:

raise e

def translate_command(client: Client, text: str) -> CommandResults:

if not text:

raise DemistoException('the text argument cannot be empty.')

response = client.translate(text)

translated = demisto.get(response, 'contents.translated')

if translated is None:

raise DemistoException('Translation failed: the response from server did not include `translated`.',

res=response)

output = {'Original': text, 'Translation': translated}

return CommandResults(outputs_prefix='YodaSpeak',

outputs_key_field=f'{TRANSLATE_OUTPUT_PREFIX}.Original',

outputs={TRANSLATE_OUTPUT_PREFIX: output},

raw_response=response,

readable_output=tableToMarkdown(name='Yoda Says...', t=output))

def main() -> None:

params = demisto.params()

args = demisto.args()

command = demisto.command()

api_key = params.get('apikey', {}).get('password')

base_url = params.get('url', '')

verify = not params.get('insecure', False)

proxy = params.get('proxy', False)

demisto.debug(f'Command being called is {command}')

try:

client = Client(api_key=api_key, base_url=base_url, verify=verify, proxy=proxy)

if command == 'test-module':

# This is the call made when clicking the integration Test button.

return_results(test_module(client))

elif command == 'yoda-speak-translate':

return_results(translate_command(client, **args))

else:

raise NotImplementedError(f"command {command} is not implemented.")

# Log exceptions and return errors

except Exception as e:

demisto.error(traceback.format_exc()) # print the traceback

return_error("\n".join(("Failed to execute {command} command.",

"Error:",

str(e))))

if __name__ in ('__main__', '__builtin__', 'builtins'):

main()

category: Endpoint

commonfields:

id: YodaSpeak

version: -1

configuration:

- defaultvalue: https://api.funtranslations.com/translate/

display: Base URL of the service

name: url

required: true

type: 0

- displaypassword: API Key

additionalinfo: The API Key to use for connection

name: credentials

required: false

hiddenusername: true

type: 9

- display: Trust any certificate (not secure)

name: insecure

required: false

type: 8

- display: Use system proxy settings

name: proxy

required: false

type: 8

description: An integration to translate English to Yodish.

display: YodaSpeak

name: YodaSpeak

script:

commands:

- arguments:

- default: false

description: The English text to translate

isArray: false

name: text

required: true

secret: false

deprecated: false

description: Use this command to translate English text.

execution: false

name: yoda-speak-translate

outputs:

- contextPath: YodaSpeak.Phrase.Translation

description: The translated text, in Yodish.

type: String

- contextPath: YodaSpeak.Phrase.Original

description: The original (English) text we translated.

type: String

isfetch: false

runonce: false

script: '-'

type: python

subtype: python3

dockerimage: demisto/python3:3.9.9.25564

fromversion: 6.0.0

tests:

- No tests (auto formatted)

Markdown file for integration configuration help snippet.

- To get an API key (for making more than 5 API calls per hour), visit the [FunTranslations subscription details page](https://funtranslations.com/api/yoda#subscribe)