Please Make a Donation:
Support This Project

Hosted by:
Get Python Knowledge Engine (PyKE) at SourceForge.net. Fast, secure and Free Open Source software downloads

KQB Syntax

This uses a different lexical structure than KRB files. Textual parameter substitution is done with the standard Python string.Template class, which specifies parameters with a $, much like pattern variables. In the following descriptions, substitution parameters are acted upon in PARAMETRIZED_TEXT, but not in TEXT.

The name of the question base is simple the filename with the .kqb suffix stripped. This must be a valid Python identifier.

PARAMETRIZED_TEXT

PARAMETRIZED_TEXT may span multiple lines. Each subsequent line must be indented at least as much as the first character of PARAMETRIZED_TEXT on the first line. Line breaks and indentation are preserved. So syntax like:

match '!' PARAMETRIZED_TEXT

Could be:

2-10 ! This is the start of the
       parametrized text.
       ^
       |
       +------ all lines must be indented at least this far!

          - what do you think?

The PARAMETRIZED_TEXT here would be:

This is the start of the
parametrized text.
^
|
+------ all lines must be indented at least this far!

   - what do you think?

But this is not legal:

2-10 ! An example of PARAMETRIZED_TEXT
      with a second line that's not indented enough!

Syntax for KQB File

file ::= [NL] {question}

question ::= IDENTIFIER '(' [{parameter,}] ')' NL INDENT
                {PARAMETRIZED_TEXT NL}
                '---' NL
                parameter '=' question_type
             DEINDENT

parameter ::= '$' IDENTIFIER

Each question has a name and a fixed number of parameters. This is followed by one or more lines of PARAMETRIZED_TEXT that will be presented as the question to answer. These are terminated by a line containing only ---.

One of the parameters is designated as the answer parameter on the line immediately following the terminating ---. This is the only parameter that may be unbound when a rule uses this question.

For example, the file user_questions.kqb might contain:

ate($meal, $ans)
    Did you eat $meal?
    ---
    $ans = yn

This question could be referenced in the premise of a rule as:

user_questions.ate(lunch, $ans)

or:

user_questions.ate(lunch, False)

But not:

user_questions.ate($meal, False)

There are several different kinds of question_types, each corresponding to a different way that the user might answer the question:

question_type ::= yn_type
                | integer_type
                | number_type
                | float_type
                | string_type
                | select_1_type
                | select_n_type

The integer_type, number_type, float_type and string_type may include a match to force the user to enter a sensible answer.

All of these may also include a review, which is just PARAMETRIZED_TEXT that will be displayed when the user's answer matches a certain match value.

Question_type links:

YN_type

yn_type ::= 'yn' NL [review]

The user answers "yes" or "no". The answer returned is True or False. If the ask_tty module is used, the user may type "yes", "y", "true" or "t" for True and "no", "n", "false", or "f" for False. These are case insensitive.

Example:

ate($meal, $ans)
    Did you eat $meal?
    ---
    $ans = yn

See review, below.

Integer_type

integer_type ::= 'integer' ['(' match ')'] NL [review]

The user enters an integer. If the match is specified, the integer must match it or the user is asked to try again.

Example:

hours_since_last_meal($ans)
    How many hours has it been since you last ate?
    ---
    $ans = integer(0-48)

See review, below.

Number_type

number_type ::= 'number' ['(' match ')'] NL [review]

The user enters either an integer or a floating point number. If the user enters an integer, a Python int is returned. Otherwise a Python float is returned.

If the match is specified, the number must match it or the user is asked to try again.

Example:

miles_to($dest, $ans)
    How many miles did you travel to get to $dest?
    ---
    $ans = number(0.1-3000)

See review, below.

Float_type

float_type ::= 'float' ['(' match ')'] NL [review]

The user enters an integer or a floating point number. But the answer returned is always a Python float.

If the match is specified, the number must match it or the user is asked to try again.

Example:

price($object, $price)
    What did you pay for $object?
    ---
    $price = float

See review, below.

String_type

string_type ::= 'string' ['(' match ')'] NL [review]

The user enters a string (text). If the match is specified, the string must match it or the user is asked to try again.

Example:

users_name($name)
    What's your name?
        - Please don't enter a fictitious (screen) name.
    ---
    $name = string(2-40)

See review, below.

Match

There are several kinds of simple_matches that may be or-ed together with |:

match ::= simple_match {'|' simple_match}

The match succeeds if any of the simple_matches succeed.

simple_match ::= '(' match ')'
               | [ STRING ] [ '[' TEXT ']' ] '/' REGEXP_TEXT '/'
               | [NUMBER] '-' NUMBER
               | NUMBER '-'
               | value '=' simple_match
               | value

Regexp Match

simple_match ::= [ STRING ] [ '[' TEXT ']' ] '/' REGEXP_TEXT '/'

A regexp match can only be used with string_type questions. It matches if the regexp matches.

If the regexp contains a single group, that group is returned as the question's answer rather than the entire string.

If the regexp contains multiple groups, a tuple of the groups is returned as the question's answer rather than entire string.

If STRING is specified on a regexp, it is used in the error message if the regexp fails. The error message is "Answer should be $error_msg, got $string".

If '[' TEXT ']' is specified on a regexp, it is used in the prompt for the end user to inform him of what is expected. Generally, this prompt message is enclosed in '[' and ']' when it is displayed to the user.

Example:

state_code($state)
    Enter your two digit state code.
    ---
    $state = string('uppercase'[uppercase]/[A-Z][A-Z]/)

Range Match

simple_match ::= [NUMBER] '-' NUMBER
               | NUMBER '-'

A range match has a '-' in it. It matches if the answer is between the two values. If either value is omitted, that limit is not tested. If matched to a string, it matches the length of the string.

Example:

age($years)
    How old are you?
    ---
    $years = integer(1-130)

Value '=' Match

simple_match ::= value '=' simple_match

The '=' means "substituted for". The match fails if the match after the '=' fails. Otherwise it returns the value before the '=' rather than what the user entered. Note that you can or (|) several of these together to translate several different matched values.

Example:

age_category($period_of_life)
    How old are you?
    ---
    $period_of_life = integer(child=1-12 |
                              teenager=13-19 |
                              young_adult=20-35 |
                              middle_age=35-64 |
                              elder=65-130)

Value Match

simple_match ::= value

value ::= STRING | IDENTIFIER | NUMBER | 'None' | 'True' | 'False'

A value match, only matches that one value. An IDENTIFIER is treated as a STRING. These are mostly used in reviews.

Review

review ::= {match '!' PARAMETRIZED_TEXT NL}

All of the reviews must be at the same indent level.

The review is applied after the answer has been validated (validation possibly changes the value).

Each match is checked and all of the matching review's PARAMETRIZED_TEXT messages are displayed to the user.

Examples:

stupid_question($ans)
    Can you answer a question
    that is several lines long?
    ---
    $ans = yn
        True  ! Correct!  This is true because the
                          sky is blue!
        False ! Nope!  Remember that the sky is blue!

wood($ans)
    How much wood would a woodchuck chuck if a woodchuck could chuck wood?
    ---
    $ans = integer(0-100)
        -10   ! more than that!
        10-20 ! bingo!
        21-   ! I guess they're not as strong as you think ...

Asking stupid_question and answering "y" to it:

>>> from pyke import knowledge_engine

>>> engine = knowledge_engine.engine('doc.examples')

>>> from io import StringIO
>>> import sys
>>> class echo(object):
...     def __init__(self, f): self.f = f
...     def readline(self):
...         ans = self.f.readline()
...         sys.stdout.write(ans)
...         return ans
>>> sys.stdin = echo(StringIO('y\n'))

displays:

>>> engine.prove_1('user_questions', 'stupid_question', (), 1)
______________________________________________________________________________
Can you answer a question
that is several lines long? (y/n) y
Correct!  This is true because the
          sky is blue!
((True,), None)

Select_1_type

select_1_type ::= 'select_1' NL alternatives

This is a multiple choice question. The alternatives are displayed to the user, and he picks one (and only one).

Example:

another_question($arg1, $arg2, $ans)
    question text with $arg1 stuff in it.
    on multiple lines
        - possibly indented
        - for who knows what reason...
            - maybe for $arg2?
    ---
    $ans = select_1
        1: prompt for this selection with $arg2 in it too
           which can span multiple lines
               - and be indented ...
           ! Nope!  Remember that the sky is blue!
        2: next prompt
           ! =1     # same review as 1:
        3: pick me! pick me!!!
           ! Correct!  You certainly know about $arg1!
             yep, multiple review lines too...
                - and indented...

Select_n_type

select_n_type ::= 'select_n' NL alternatives

This is a multiple choice question. The alternatives are displayed to the user, and he picks as many as he likes.

Example:

problems($list)
    Which of these problems are you experiencing?
        - select all that apply
    ---
    $list = select_n
        boot: The system won't boot.
        os: I hate Windows!
        internet: I can't connect to the internet.
        slow: The system is running too slow.
        ouch: Help!  I've fallen and I can't get up!
        freeze: The system freezes or does not respond to input.
        printer: The printer doesn't work.
        senile: What's email?

Alternatives

alternatives ::= {value ':' PARAMETRIZED_TEXT NL [alt_review]}

All of the alternatives must be at the same indent level.

The user only sees the PARAMETRIZED_TEXT values. The value associated with the selected PARAMETRIZED_TEXT is returned (but the user never sees it). The value tags the alternative.

alt_review ::= '!' '=' value NL
             | '!' PARAMETRIZED_TEXT NL

Each alternative may have it's own review associated with it.

The '!' '=' value form uses the same review text as the previous alternative with that tag. Note that this can not refer forward to a following alternative.

The second form specifies the review text for this alternative directly.

More:

KFB Syntax

The syntax of Knowledge Fact Base (KFB) files, which is where you write your universal facts.

KRB Syntax

Syntax of the Knowledge Rule Base (KRB) files, which is where you write your rules.

KQB Syntax

The syntax of Knowledge Question Base (KQB) files, which is where you spell out your end user questions.

Page last modified Wed, Mar 25 2009.