Custom Conversations

Summary

Create your own or use text script files shared by other users.

Requirements

No special required packages for this skill.

Description

Skill, which works using the custom text parsing implementation, provides the functionality to create, share, modify, and use any script files obtained from the shared library.

How to Use

Scripts update automatically when Neon is started; you can start a script by saying:

Neon run my <script name> skill file

If the script has any synonyms specified, you may also use a synonym to start the script. If the script has any defined tags, you can start the script at the tag by saying:

Neon run my <script name> skill file at <tag name>

What are scripts?

Scripts are user-constructed text files that contain various Neon commands. Using a few simple keywords, described below in the detail, you can specify exactly what Neon should say, do, repeat, and answer; you can create new dialogs, routines, loops, and query lookups, while utilizing every skill, YAML variable, and other information that Neon knows.

For example:

Script: "Demo Hello World Input"
Variable: {input}: ""
Neon speak: "Hello World. Say anything or exit"
voice_input{input}
Neon speak: "you said {input}"
Exit

Scripts are easily sharable between other users via the Neongecko Scripts Library. You can submit your script there to share with all the other Neon users.

You can also find various demo scripts there if you need somewhere to start or something to reference.

Starting a Script File

Scripts must begin with a Script: line containing the script name and then any optional Variable, Claps, Language, and Synonym lines. After this, you can continue with any of the other script commands. It is recommended to include a Neon Speak statement to tell the user what they can do/how to proceed prior to requesting any user input.

Script: "Demo Weather Time Population"
Language: "en-au female"
Variable: {response}: ""
Synonym: "WTP"

Language

This sets the language Neon will use for script responses while the script is active. This will not affect a user's profile or responses they get from Neon outside of the script. The valid language codes are:

zh-zh, da-dk, nl-nl, en-au, en-gb, en-in, en-us, en-gb-wls, fr-fr, fr-ca, de-de, hi-in, is-is, it-it, ja-jp, ko-kr, nb-no, pl-pl, pt-br, pt-pt, ro-ro, ru-ru, es-es, es-mx, es-us, sv-se, tr-tr, cy-gb, cmn

Any of the above language codes may also be used without the region code (i.e. "en" is equivalent to "en-us"). "male" or "female" may also be specified either before or after the language code; the default gender is "female".

Language: "en-us female"

Variable

A variety of parameters to be used later in the script. Can be preset or empty. All variables will be saved as a list with the most recent value at index 0 and previous values appended. table_scrape will build a dictionary of named links as options. List variables may occupy more than one line; subsequent lines should be indented from the Variable: line. Variables used for simple word substitutions will contain pairs of strings where each pair is separated by a comma. Variables used for conversational responses will contain multiple quoted string sets with each set separated by a comma.

Simple Variable declarations:

    Variable: {from_units}: ""
    Variable: {conversions}: weight, volume, length, time, currency
    Variable: {options}: table_scrape(https://www.neongecko.com/demos)

Word Substitutions:

Variable: input_sub = dont don't,
    cant can't,
    wont won't,
    recollect remember

Conversational Responses:

Variable: key_sub = "[sorry] for *" "Please don't apologize about *" "No need to apologize about *",
    "i remember when {1} said {2}" "Do I think of {1} or {2} often?",
    "*" "I don't understand. Please elaborate." " What do you mean by *?"

Synonym

Specifies a phrase that can be used to start this skill file. After the script is run the first time, the synonym will be added to the user's synonyms. After this, the synonym can be used to run the script. For example:

Case: "Run My TPW Skill File"  
Synonym: "T P W 2"

Claps

The number of claps that should be associated with starting the script.

Claps: 2  

Script Keywords and Spacing

Neon scripts follow the Python convention of 4 spaces to indent subordinate lines. A line without a command will be considered a subordinate of the previous line that has one fewer indent; for example, all of the lines below after Neon speak: would be spoken:

Neon speak:
    "Say 1 or World Times for world times"
    "Say 2 or World Weather for world weather"
    "Say 3 or World Populations for world populations" 

There are multiple keywords available and new ones are added frequently. The current list, starting with the core example above:

Neon speak

Literal string to be spoken by Neon. A single line to speak can be on the same line as Neon speak:. If multiple lines are to be spoken, they should follow Neon speak: and be indented. SSML is supported in Neon speak and Name speak commands if they are supported by the selected TTS engine. Examples of ssml supported by Amazon Polly can be found here.

Neon speak: "Hello World. Say anything or exit"
Neon speak:
    "Say 1 or World Times for world times"
    "Say 2 or World Weather for world weather"
    "Say 3 or World Populations for world populations"

Name speak

Literal string to be spoken as a specified speaker. Name is required, gender and language may optionally be specified as comma-separated parameters. If one of gender or language are specified, the other will use the user's profile setting or script setting if available. SSML is supported in Neon speak and Name speak commands if they are supported by the selected TTS engine. Examples of ssml supported by Amazon Polly can be found here. SSML is supported in Neon speak and Name speak commands if they are supported by the selected TTS engine. Examples of ssml supported by Amazon Polly can be found here.

Name Speak: Nobody: "Or I can speak as someone else."
Name Speak: Slow Male, male: "<prosody volume="-2dB" rate="x-slow" pitch="x-low">I can be quiet, slow, and deep</prosody>"
Name Speak: English Male, male, en-us: "<prosody volume="-2dB" rate="x-slow" pitch="x-low">I can be quiet, slow, and deep</prosody>"

Execute

String to be executed as if spoken by a user. A single line to execute can be on the same line as Execute:. If multiple lines are to be executed, they should follow Execute: and be indented. When a string is executed, Neon will wait several seconds for a response before continuing. Any commands will be executed as if a wake word was heard, so "Neon" is not required in front of any commands.

Execute: "What time is it in Athens"
Execute:
    "neon translate cherry to russian"
    "neon tell me my language setting
    "neon speak to me in english
    "neon speak to me in Russian and French
    "neon speak to me in english

Tag

Lines with @ as the first non-whitespace character will be indexed as Goto tag lines. A tag line should be one word and contain only a string label.

@test_tag

####Goto Command to go to the specified line or tag in the script. The argument to this command can be either a file line number (the line specified will be executed next) or a tag that is defined in the script (the line following the tag will be executed next). Tags may reference a line at any position in the file. When writing a script with Goto commands, avoid entering your script at case option lines and consider where variables are set to avoid using a variable before setting it (i.e. with voice_input.

Goto: test_tag
Goto: 5

Comments

Lines with # as the first non-whitespace character will not be executed. Comment lines are useful for annotating a script or removing problematic lines when troubleshooting. (ex. you remove a line and leave a comment for why the line is commented out). Block comments are also allowed where blocks start and end with """.

# Removed speak to troubleshoot voice_input
    # Neon speak:
    #     "Say your first name or exit" voice_input{first_name}
"""
    This is inside a block comment.
You can put in longer comment strings here, or surround a section of code
"""

voice_input

Specifies when a variable needs to be filled with user input. If an optional list of options is provided, the script will wait for user input to match one of those options, otherwise the next user input will be used. Once the variable has been assigned a value, the script will continue at the following line. Variables will preserve a history of previous values in a list. It is recommended that any voice_input follows a Neon speak: prompting the user to say something.

    Variable: {input}: ""
    Neon speak: "Hello World. Say anything or exit"
    voice_input{input}
    Neon speak: "you said {input}"
    Neon speak:
        "Say 1 or World Times for world times"
        "Say 2 or World Weather for world weather"
        "Say 3 or World Populations for world populations"
    voice_input{response}
    Case {response}:
Variable: {selected}: ""
Variable: {conversions}: weight, volume, length, time, currency
Neon speak: "Say convert select_one{conversions} to convert or exit when done"
voice_input{selected,conversions}

If/Else

If statements can be used to evaluate variable values. If a comparator is not given, the variable will be evaluated as a boolean, where values of 0, false, none, null, no, and "" are false and any other value is true. Valid comparators are in, > ,<, >=, <=, == and != and variables may be compared to other variables or to static values. String comparisons follow Python3 rules.

Variable: {test}: "False"

if {test}:
    Neon speak: "True"
else:
    Neon speak: "False"
Neon speak: "Say 'continue' to continue"
voice_input{test}

if {test} == "continue":
    Neon speak: "Okay, lets continue"
else:
    Neon speak: "Okay, exiting."
Neon speak: "Say {conditional} to continue"
voice_input{test}

if {test} != {conditional}:
    Neon speak: "Not matched, exiting"
    Exit
else:
    Neon speak: "Okay, lets continue."

Case

Case statements can be used to execute different commands based on some variable value. Case statements often follow a voice_input to assign a variable value, but may also use a variable that has already been defined. Case options should follow the Case: line and be indented from that line by one. Commands to run if the case option is satisfied should be indented from that case option. A Case: will execute the first matched option and then continue at the next line following the end of the case; if no option is matched, the script will go back to the voice_input line immediately before the case. Case options containing "or" will compare the Case variable against the string on either side of "or".

Neon speak:
    "Say A or Athens for Athens's time"
    "Say B or Bombay for Bombay's time"
    "Say S or Seattle for Seattle's time"
voice_input{response}
Case {response}:
    "A or Athens"
        Execute: "What time is it in Athens"
    "B or Bombay"
        Execute: "What time is it in Bombay"
    "S or Seattle"
        Execute: "What time is it in Seattle"
# Script continues here
Exit

Python

Any line of python 3 readable code will be executed in the order it was specified in the script file. These lines will execute and then continue to the next line of the script; you may assign the output of a valid Python operation to a script variable to use later in your script. The time module is available in addition to any builtin methods.

Currently, the following math operations are supported: +, -, /, *, % (modulus), ** (power), ln(x), log(x) (log base 10), sqrt(x), and common trigonometry functions (sin, cos, tan, sinh, cosh, tanh, asin, acos, atan). The constants e and pi are also available.

Python: time.sleep(5)
Python:
    hypotenuse = sqrt({side_1}**2 + {side_2}**2)

Exit

Exit command to finish the script. Could be positioned anywhere in the document. Note: your script should always exit somewhere, this is often simply on the last line and indented by 0.

Exit  

Loop

Loops are defined by a starting line and an ending line with optional conditions. A loop begins where LOOP is declared with a name and ends where a LOOP END or LOOP UNTIL line is reached. A loop can always be exited when the user says "exit", otherwise the loop will run until the UNTIL condition is met or indefinitely if no UNTIL condition is met. Provides familiar functionality as loops. Can be nested and combined with other statements. Positioned at the beginnings and end of a Case statement. A loop is started with the keyword LOOP followed by a name and terminated by name with the keyword END as noted below.

No end condition defined, this loop will continue until the user says "exit".

LOOP WW
    Neon speak:
        "Say A or Athens for the weather in Athens"
        "Say B or Bombay for the weather in Bombay"
        "Say S or Seattle for the weather in Seattle"
        "Say exit to exit"
    voice_input{location}
    Case {location}:
        "A or Athens"
            Execute: "What is the weather in Athens"
            Neon speak: "about to repeat A"
        ...
     Neon speak:
         "End of loop WW."
LOOP WW END

A loop until a specified variable has been filled in with the defined values:

LOOP WW
    Neon speak:
        "Say A or Athens for the weather in Athens"
        "Say B or Bombay for the weather in Bombay"
        "Say S or Seattle for the weather in Seattle"
        "Say exit to exit"
    voice_input{location}
    Case {location}:
        "A or Athens"
            Execute: "What is the weather in Athens"
            Neon speak: "about to repeat A"
        ...
     Neon speak:
         "End of loop WW."
LOOP WW UNTIL location == "b"

Set

You may set variables equal to other variable values or static values with the keyword Set anywhere in a script. This can be useful to save a variable value before modifying the variable

    Set: user_speech = {input}

sub_values

Accepts a variable string to modify and a list variable containing substitution pairs. Any word matched to the first word of a substitution pair will be replaced with the second word of that pair in the passed variable.

Variable: input_sub = dont don't,
    cant can't,
    wont won't,
    recollect remember
...
sub_values{input, input_sub}

sub_key

sub_key is a simplified method for matching a user's input to a pattern and then generating a response associated with that pattern. sub_key accepts a string variable to match and a list variable containing strings to match and associated responses. Wildcards (*) and new variables ({var_1}) may be used in the strings to match and the associated responses to include parts of the input in the response. Multiple wildcards will be evaluated positionally (i.e. the first wildcard in the input will be used as the first wildcard in the output). sub_key executes such that the first matched response in the associated responses list will be used; this allows a catch-all wildcard to be used at the end of the list to handle any input that doesn't match a specified pattern. Bracketed strings ([string]) reference a list variable so that any word in the variable is accepted as a match. Note: wildcard variables are only available for the current substitution; named variables are available for use later in the script until overwritten.

Variable: sorry = sorry, i apologize
Variable: key_sub = "[sorry] for *" "Please don't apologize about *" "No need to apologize about *",
    "i remember when {1} said {2}" "Do I think of {1} or {2} often?",
    "*" "I don't understand. Please elaborate." " What do you mean by *?"
...
sub_key{input, key_sub}

In-text options (Used to fill a string with a variable):

select_one

Specifies that the value will have to be filled in by user's choice from the provided list of items before proceeding. Used in Neon speak statements to speak the available options for a variable.

Variable: {conversions}: weight, volume, length, time, currency  
Neon speak:  
"Say convert select_one{conversions} to convert or exit when done"

table_scrape

Uses beautiful soup to give back a readable and searchable dictionary of text/link pair of any HTML table element on a provided web page.

Variable: {options}: table_scrape(https://www.neongecko.com/demos)

random

Returns random elements of the given list variable. If used to set a variable, one value will be assigned; in a Neon speak, 2-3 examples will be provided and spoken.

Variable: {numbers}: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
Variable: {neon_num}: random{numbers}
    Variable: {options}: table_scrape(https://www.neongecko.com/demos)  
    Variable: {chosen}: ""  
    Neon speak:  
        "Please tell me what kind of help video you would like to see. You can say things like random{options}"

closest

Returns the closest element of a list to the specified variable (generally used in combination with table scrape). Optimized for string processing.

Execute: "av play closest{chosen,options}"

profile

Lookup a value from a user profile to use in a speak or execute command.

profile{user.email}

How to Use

Scripts can be downloaded from Neongecko's library or written from scratch. The demo skill files and descriptions above provide a summary and examples of the available functionality and formatting requirements.

Contact Support

Use the link or submit an issue on GitHub

Credits

reginaneon neongeckocom

Subscribe Here! * Keep Up to Date on Neon AI * Get GitHub SDK Credentials

* Get Neon AI in One Line of HTML * Get the Neon AI App for Android from Google Play