June | 2013 | pixel by pixel

Archive for June 29, 2013

Justin | June 29, 2013

Week 2 – Web Performance Fever

I spent this week cutting my teeth on test automation by revising a set of web performance acceptance tests for an internal database tool. Web performance tests are basically coded scripts that run against a web service, validating that certain functionalities are present and that response times are within the defined standard. Besides just revising and updating the existing test suite, I also created several new tests for features that were not already within the test coverage.

I spent a good chunk of time defining a set of reusable components for basic things like page navigation, so that creating future web performance tests tests is somewhat streamlined. By the time I was done with these, I had learned quite a bit about HTTP and data extraction from web services. I now feel confident in my own ability to create a set of meaningful automated tests of a web page/web service.

I also took some time to explore creating my own sample WCF (Windows Communication Foundation) web service and client application. This was just an ASPX webpage interface that let a user browse and edit an underlying SQL database. It was a pretty basic program but gave me a deeper understanding of what was going on under the hood of the web services I’ve been working on.

Other than all that, I also met with my supervisor and received a high-level overview of performance engineering. Now that I have learned basic web performance testing, I will move on to learning about creating and analyzing load, stress, stability, failover, and endurance tests– whew! It’s going to be a busy summer.

Oh, and a couple personal highlights– the office ergonomics expert switched out my old chair for a giant, awesome new chair that looks like a CEO should be sitting in it. Definite upgrade! Also, the intern who sits next to me had been out sick all week, and I came in one day to find this:

You would think WotC, of all places, would keep a cleric on staff to remove curses.

A couple of times, I could swear I saw its hand move out of the corner of my eye…

Looking forward to diving into more testing next week!

Category: Computing, My Internship at Wizards of the Coast | Tags: internship, wotc

Justin | June 22, 2013

No comments

Week 1 – Getting My Feet Wet

I began my internship this week. I had about a week beforehand to prepare, so I crammed as much as I could on materials covering software testing and the C# programming language.

I attended my new hire orientation and met the team I’ll be working with. Everyone has been very welcoming so far. The offices are fantastic; being a company that makes games, there is art and sculpture everywhere. The cubicles are all decked out with decorations and overall it feels very comfortable as far as office buildings go. And there is a giant dragon in the lobby!

Me and Mitzy, the resident lobbydragon.

As far as actual work goes, my first week was mostly spent oriented myself with their software and culture. Ernie (my supervisor) supports several different teams around the office, so it seems like I’ll get exposed to a variety of projects and methodologies. On his advice, I am working my way through a book called “Professional Application Lifecycle Management with Visual Studio 2010”.

Techniques I learned this week included initial exploration of Visual Studio’s suite of test tools. I also wrote some man pages about various testing tools for the internal wiki; this was a good exercise that helped acquaint me with the tools and their functionality. I attended daily standup meetings with the Software QA team and will continue to do so.

Culturewise, I attended a couple of company gaming sessions including a confidential playtest for an unreleased product. It was a blast!

Overall, it has been a very positive experience thus far. More to come!

Category: Computing, My Internship at Wizards of the Coast | Tags: dragon, internship, wotc

Justin | June 14, 2013

No comments

Internship – Performance Engineering

Performance Engineering is an internship designed to expose the student to real-world experience as a Software Development Engineer in Test (SDET). The student will work alongside an experienced SDET at Wizards of the Coast (a subsidiary of Hasbro) to build new performance test automation, maintain existing automation, execute performance tests and analyze test results.

This blog will chronicle my experiences as a Performance Engineering intern at Wizards of the Coast. Having been a WotC fan for many years, this internship is in many ways a dream come true. I will be working under the mentorship of WotC’s Ernie Nelson (Senior SDET) and Evergreen’s Sheryl Shulman (Professor of Computer Science).

Stay tuned for weekly summaries of what I’m learning, challenges I’ve encountered, and workplace experiences in general!

Category: Computing, My Internship at Wizards of the Coast | Tags: internship, wotc

Justin | June 5, 2013

No comments

Project Summary: Natural Language Processing With Prolog

For my “Computing Practice and Theory” project, I chose to continue some of the work with Prolog and EBNF grammar parsing that I had begun in the “Computability” program. Specifically, I wanted to study more about Natural Language Understanding– the process of gleaning intended meaning from natural language.

As Natural Language Processing can be a bit dry, I decided to put a fun spin on the project; I designed and implemented a small command grammar for a Scribbler II robot. The Scribbler II is a simple educational robot which has a python-based interface library called Myro available.

My program, tentatively titled “ScribPro”, is a hybrid python/prolog application that allows control of a Scribbler via natural language. All communication with the robot is transmitted over Bluetooth. The python component handles initialization, messaging to & from Prolog, code execution, and both fetching and sanitization of user input. I was learning python on the fly as I did this project, so the final python component is pretty messy… but by the end of the quarter I felt that I have achieved basic competency. I am very glad that I learned it; the ability to use python quickly create simple programs or prototype has already proven itself invaluable.

The Prolog component handles the bulk of the parsing work. It reads the sentence fed to it from the python component, determines whether or not it is a successful parse, and if it is, converts the parse tree into a functor which it passes back to python. The validity of a parse is determined according to a grammar. Early on in the project, I tried to write a very abstract grammar using only the rules of the English language, and quickly realized that it was beyond the scope of this project. This dilemma is one that anyone trying to do natural language parsing inevitably encounters: English is a messy language! In order to overcome this and make a usable program within a ten-week timeframe, I chose to severely bound the words and sentential forms that my program would recognize. Limiting the scope of my grammar to natural language units that are applicable to robot control made the project feasible.

While the final grammar never grew quite as complex as I would’ve liked, I am pretty happy with how the project turned out. The robot is able to parse & execute a variety of movement-based commands — from plain English!

Not only is the robot able to handle simple sentences such as “Please go forward”, it can handle fairly complex compound sentences such as:

“Spin in a circle to the left two times.”
“Go forward four point five feet and turn left, then wait nine hundred milliseconds, turn around and beep once.”
“Scoot forward until you reach the wall, then move backwards two inches, turn around and beep.”

Beyond the basic text mode, there is an optional voice input mode that taps into the Microsoft Speech Engine. It is pretty fun to vocally order the robot around!

The fact that I was using two programming languages in tandem (prolog & python) presented some significant initial difficulties in the project. A good portion of my final code revolves around passing messages back and forth between the two. The tradeoff was worth it, however– had I been forced to implement my program in a single language, it would have been quite a bit messier. There is something to be said for using the right tool for the job. By the end of the project, I gained a substantial amount of confidence in my own ability to multiple languages within a single project. No doubt this will come in handy in the future.

Here is a diagram of the program flow and component design of my final program:

I now feel confident that I have a handle on the basics of natural language parsing using grammars, and believe that I could implement such a system again in a much shorter timeframe, with a more elegant end result.

If I were to revise this project, I would attempt to abstract the code-generation side to be a level higher. Right now, the code generated from a successful parse is extremely Scribbler-specific… which I would like to rectify. I could conceivably create my own generic set of common robotics-related functions which the parser would invoke, rather than having it call specific Myro functions. I would then implement the ability to map these generic functions to model-specific ones via config files; essentially allowing the parser to be used for other types of robots with ease.

Overall, I had quite a bit of fun with this project, whilst still managing to feel like I challenged myself. I look forward to further independent research into Prolog, as I feel that logic programming is a valuable yet underutilized programming paradigm. I also look forward to further tinkering with more advanced robotics projects.

Past weekly blog updates can be found at the following links:

My final code can be found here:

scribpro.py – Python Main Program Executable
nlp.pl – Prolog Natural Language Parsing Component

(Please be forgiving of the code, as I am an undergrad and was learning by doing for most of it. There are approximately a million things I would change if I could do it all over again.)

If anyone reading this has any questions or is working on a related project, I’d love to hear from you!

Category: Computing, Junior Project - NLP Robot | Tags: ai, project, prolog

Justin | June 5, 2013

No comments

nlp.pl

% Natural Language Parser for Scribbler II Robot
% by Justin Mangue, 2013
%
% Uses DCG grammar parsing to parse natural language input into Python code, to be executed on a Scribbler II robot.
%
% References used:
% * "The Art of Prolog", Sterling & Shapiro, 1986.
 
% ParseToCode is the main routine.  Takes a sentence and converts it to a list of executable python code.
% Call with parseToCode([sentence,as,a,list],Status,Code).
parseToCode(Sentence, Status, CodeListOut) :-
    compound_sentence(ParseList, Sentence, []),
    Status = valid,
    generate_code_list(ParseList, [], CodeListOut), 
    !.  
     
parseToCode(Sentence, Status, CodeOut) :-
    + compound_sentence(_, Sentence, []),
    Status = invalid_sentence,
    CodeOut = 'null',
    !.
     
%%% GRAMMAR DEFINITIONS %%%
     
% Compound Sentence is the top level.  Consists of an optional address statement followed by one or more simple sentences joined by a connective.
compound_sentence(Compound) -->
    optionally_address(robot),
    simple_sentence(Command),
    connective(and),
    compound_sentence(Sentence),
    { append([Command], [Sentence], Compound_NotFlat) },
    { flatten2(Compound_NotFlat, Compound) }.
 
compound_sentence(Command) -->
    optionally_address(robot),
    simple_sentence(Command).
     
% A simple sentence is a command phrase, possibly followed by an optional repetition clause.
simple_sentence([loop(C,T)]) --> 
    command_phrase(C), 
    (to_number(T), [times] ; to_number_eng(T)).
     
simple_sentence([Simple]) --> 
    command_phrase(Simple).
   
% Command phrases are the basic command-level structure.  Most consist of an action and some sort of argument.
command_phrase(move(D,S)) --> 
  action(go), 
  direction(D),
  optional(for),
  unit_to_seconds(S).
   
command_phrase(move(D,S)) --> 
  action(go), 
  unit_to_seconds(S),
  direction(D).
   
command_phrase(move(forward,S)) --> 
  action(go), 
  unit_to_seconds(S).
   
command_phrase(move(D,3)) --> 
  action(go), 
  direction(D).
   
command_phrase(turn(D,S)) --> 
  action(turn), 
  optional(to),
  (optional(the) ; optional(your)),
  direction(D), 
  unit_to_seconds(S).
 
command_phrase(turn(D,S)) --> 
  action(turn), 
  optional(to),
  (optional(the) ; optional(your)),
  direction(D),
  { S is 90*(3.25 / 360) }.  % 90 degrees by default
   
command_phrase(turn(right,D)) -->
  action(turn),
  direction(around),
  { D is 180 * (3.25 / 360) }.  % 180 degree turn
   
command_phrase(turn(Dir,D)) -->
  action(spin),
  direction(around),
  optional(to),
  (optional(the) ; optional(your)),
  direction(Dir),
  { D is 3.25 }.  % 360 degree turn
   
command_phrase(turn(right,D)) -->
  action(spin),
  direction(around),
  { D is 3.25 }.  % 360 degree turn
     
command_phrase(pic(Mode)) -->
    action(take),
    adposition(a),
    photomode(Mode),
    object(picture).
     
command_phrase(pic(0)) -->  % b&w pic by default, for speed reasons
    action(take),
    adposition(a),
    object(picture).
     
command_phrase(wait(S)) -->
    action(wait),
    optional(for),
    unit_to_seconds(S).
     
command_phrase(wait(3.0)) -->
    action(wait).   
     
command_phrase(beep) -->
    action(beep).
     
command_phrase(moonwalk(S)) -->
    action(moonwalk),
    optional(for),
    unit_to_seconds(S).
     
command_phrase(moonwalk(4.0)) -->
    action(moonwalk).
     
command_phrase(move_until_wall(D)) -->
    command_phrase(move(D,_)),
    condition(until),
    [you],
    condition(encounter),
    object(wall).
     
% Vocabulary/synonym definitions
     
action(go) --> [go] ; [move] ; [drive] ; [roll] ; [scoot].
action(turn) --> [turn] ; [rotate] ; [swivel].
action(spin) --> [spin].
action(take) --> [take] ; [obtain] ; [get] ; [snap].
action(wait) --> [wait] ; [pause] ; [stop].
action(beep) --> [beep].
action(moonwalk) --> [moonwalk].
 
direction(forward) --> [forward] ; [forwards] ; [ahead] ; [up].
direction(backward) --> [backward] ; [backwards] ; [back].
direction(left) --> [left] ; [counter-clockwise] ; [counter],[clockwise].
direction(right) --> [right] ; [clockwise].
direction(around) --> [around] ; [in],adposition(a),[circle].
 
adposition(a) --> [a] ; [one].
 
condition(until) --> [until].
condition(encounter) --> [encounter] ; [reach] ; [sense] ; [hit].
 
photomode(0) --> [grayscale] ; [greyscale] ; [gray] ; [grey] ; [black],[and],[white] ; [black],[&],[white].
photomode(1) --> [color].
 
object(picture) --> [photo] ; [picture] ; [pic] ; [snapshot].
object(wall) --> [a],[wall] ; [the],[wall] ; [an],[obstacle] ; [something].
 
pronoun(robot) --> [robot] ; [scribbler].
 
connective(and) --> [and] ; [then] ; [comma] ; [and], [then] ; [comma], [then] ; [comma], [and], [then].
 
% Optional form of address
optionally_address(robot) -->
    (optional(robot) ; optional(scribbler)),
    optional(comma),
    optional(please).
     
% Allow a DCG word to be optional
optional(X) --> [X] ; [].
 
% Number parsing predicates
% English number recognition from 0.0 - 9999.9
 
to_number(N) --> num(N1), [point], digit(N2), { N is N1 + (0.1 * N2) }.
to_number(N) --> num(N).
 
to_number_eng(1) --> [once].
to_number_eng(2) --> [twice].
to_number_eng(3) --> [thrice].
 
num(0) --> [zero].
num(N) --> xxxx(N).
num(N) --> xxx(N).
num(N) --> xx(N).
num(N) --> digit(N).
 
num(N) --> [N], { number(N) }.
 
xxxx(N) --> digit(D), [thousand], xxx(N1), { N is D*1000+N1 }.
xxx(N) --> digit(D), [hundred], rest_xxx(N1), { N is D*100+N1 }.
 
rest_xxx(0) --> [].
rest_xxx(N) --> [and], xx(N).
rest_xxx(N) --> xx(N).
 
xx(N) --> digit(N).
xx(N) --> teen(N).
xx(N) --> tens(T), rest_xx(N1), { N is T+N1 }.
 
rest_xx(0) --> [].
rest_xx(N) --> digit(N).
 
digit(1) --> [one].
digit(2) --> [two].
digit(3) --> [three].
digit(4) --> [four].
digit(5) --> [five].
digit(6) --> [six].
digit(7) --> [seven].
digit(8) --> [eight].
digit(9) --> [nine].
 
teen(10) --> [ten].
teen(11) --> [eleven].
teen(12) --> [twelve].
teen(13) --> [thirteen].
teen(14) --> [fourteen].
teen(15) --> [fifteen].
teen(16) --> [sixteen].
teen(17) --> [seventeen].
teen(18) --> [eighteen].
teen(19) --> [nineteen].
 
tens(20) --> [twenty].
tens(30) --> [thirty].
tens(40) --> [forty].
tens(50) --> [fifty].
tens(60) --> [sixty].
tens(70) --> [seventy].
tens(80) --> [eighty].
tens(90) --> [ninety].
 
% Scribbler Unit conversions
% All of the Myro commands for Scribbler are expressed in seconds, so conversions of other unit types to seconds are required.
 
% Seconds -> Seconds
unit_to_seconds(S) -->
    to_number(S), { + S = 1 }, [seconds] ;
    to_number(S), { S = 1 }, [second].
     
% Milliseconds -> Seconds
unit_to_seconds(MS) -->
    to_number(S), { + S = 1 }, { MS is (S / 1000) }, [milliseconds] ;
    to_number(S), { S = 1 }, { MS is (S / 1000) },[millisecond].
 
% Feet -> Seconds
unit_to_seconds(S) -->
    to_number(Feet), { + Feet = 1 }, { S is Feet * 2.05 }, [feet] ; 
    to_number(Feet), { Feet = 1 }, { S is 2.05 }, [foot].
 
% Inches -> Seconds
unit_to_seconds(S) -->
    to_number(Inches), { + Inches = 1 }, { S is Inches * (2.05 / 12) }, [inches] ; 
    to_number(Inches), { Inches = 1 }, { S is (2.05 / 12) }, [inch].
     
% Degrees -> Seconds
unit_to_seconds(S) -->
    to_number(Degrees), { + Degrees = 1 }, { S is Degrees * (3.25 / 360) }, ([degrees] ; [º]) ;
    to_number(Degrees), { Degrees = 1 }, { S is (3.25 / 360) }, ([degree] ; [º]).
     
%%% CODE GENERATION %%%
% The top level structure is a code list, which is a list of one or more code fragments to be executed.
% This part is pretty messy, but is needed to handle passing instructions back to Python from Prolog.
 
generate_code_list([], CodeList, CodeList).
generate_code_list([H|T], CodeList, CodeListOut) :-
    generate_code(H, CodeLineOut),
    append(CodeList, CodeLineOut, NewCodeList),
    generate_code_list(T, NewCodeList, CodeListOut).
 
generate_code(move(forward,S), CodeOut) :-
    string_to_atom(Keyword, forward),
    CodeOut = [[Keyword,1.0,S]], !.
 
generate_code(move(backward,S), CodeOut) :-
    string_to_atom(Keyword, backward),
    CodeOut = [[Keyword,1.0,S]], !.
 
generate_code(move(left,S), CodeOut) :-
    string_to_atom(Keyword1, turnLeft),
    string_to_atom(Keyword2, forward),
    Ninety is 90*(3.25 / 360),
    CodeOut = [[Keyword1,1.0,Ninety],[Keyword2,1.0,S]], !.
     
generate_code(move(right,S), CodeOut) :-
    string_to_atom(Keyword1, turnRight),
    string_to_atom(Keyword2, forward),
    Ninety is 90*(3.25 / 360),
    CodeOut = [[Keyword1,1.0,Ninety],[Keyword2,1.0,S]], !.
     
generate_code(turn(left,S), CodeOut) :-
    string_to_atom(Keyword, turnLeft),
    CodeOut = [[Keyword,1.0,S]], !.
     
generate_code(turn(right,S), CodeOut) :-
    string_to_atom(Keyword, turnRight),
    CodeOut = [[Keyword,1.0,S]], !.
     
generate_code(wait(S), CodeOut) :-
    string_to_atom(Keyword, wait),
    CodeOut = [[Keyword,S]], !.
     
generate_code(pic(Mode), CodeOut) :-
    string_to_atom(Keyword, takePhoto),
    CodeOut = [[Keyword,Mode]], !.
 
generate_code(beep, CodeOut) :-
    string_to_atom(Keyword, beep),
    CodeOut = [[Keyword,0.4, 640]], !.
     
generate_code(loop(C,T), CodeOut) :-
    generate_code(C,Code),
    append_n_times(Code,[],T,CodeOut), !.
     
generate_code(move_until_wall(forward), CodeOut) :-
    string_to_atom(Keyword, move_until_wall),
    CodeOut = [[Keyword]], !.
     
generate_code(move_until_wall(left), CodeOut) :-
    string_to_atom(Keyword1, turnLeft),
    string_to_atom(Keyword2, move_until_wall),
    Ninety is 90*(3.25 / 360),
    CodeOut = [[Keyword1,1.0,Ninety],[Keyword2]], !.
     
generate_code(move_until_wall(right), CodeOut) :-
    string_to_atom(Keyword1, turnRight),
    string_to_atom(Keyword2, move_until_wall),
    Ninety is 90*(3.25 / 360),
    CodeOut = [[Keyword1,1.0,Ninety],[Keyword2]], !.
 
generate_code(move_until_wall(backward), CodeOut) :-
    string_to_atom(Keyword1, turnRight),
    string_to_atom(Keyword2, move_until_wall),
    string_to_atom(Keyword3, turnLeft),
    OneEighty is 180*(3.25 / 360),
    CodeOut = [[Keyword1,1.0,OneEighty],[Keyword2],[Keyword3,1.0,OneEighty]], !.
 
generate_code(moonwalk(S), CodeOut) :-
    string_to_atom(Keyword, moonwalk),
    CodeOut = [[Keyword,S]], !.
     
%%%  MISC SUPPORT PREDICATES %%%
 
% Check if S is a sublist of L
sublist(S, L) :-
  append(_, L2, L),
  append(S, _, L2).
   
% Builds a list of N instances of item C, then returns the result in L
append_n_times(_,L,0,L):- !.
append_n_times(C,L,N,Result):-
    append(L,C,NewL),
    NewN is N-1,
    append_n_times(C,NewL,NewN,Result).
  
% Flatten a list of lists
flatten2([], []) :- !.
flatten2([L|Ls], FlatL) :-
    !,
    flatten2(L, NewL),
    flatten2(Ls, NewLs),
    append(NewL, NewLs, FlatL).
flatten2(L, [L]).

Category: Uncategorized | Tags: code, prolog

Justin | June 5, 2013

No comments

scribpro.py

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

# coding=latin-1
#
# File: scribpro.py
# by Justin Mangue
#
# Description:
# This is a script that enables use of a Prolog natural language parsing component to control a Scribbler II robot
# over bluetooth.  Use in sync with nlp.pl.
#
# Dependencies:
# Python 2.7.4         http://www.python.org/getit/      
# PySwip 0.2.3         https://code.google.com/p/pyswip/
# PySpeech             https://code.google.com/p/pyspeech/
# Myro 2.9.5           http://myro.roboteducation.org/download/
# Swi-Prolog 6.2.6     http://www.swi-prolog.org/Download.html
 
# IMPORTS
from sys import exit
from myro import *
from pyswip import Prolog
import speech as pyspeech
 
# GLOBAL SETTINGS
verNum = '0.6'              # ScribPro Version Number
scribblerPort = 'COM5'      # Scribbler Bluetooth Port
prologFile = 'nlp.pl'       # Prolog file to consult
debug = 'on'                # Debug mode, if enabled, shows detailed prolog parse information
inputMode = "text"          # Input in text mode by default
outputMode = "text"         # Output to text by default
 
# CLASSES
class PrologResult(object):
  def __init__(self, prologcall, status, pythoncode):
     self.prologcall = prologcall
     self.status = status
     self.pythoncode = pythoncode
 
# FUNCTIONS
 
def strClean(string):
    """ strClean(str) -- converts "A string like This" into a list of lowercase atoms
        i.e. [a,string,like,this] for use in Prolog. also converts commas to "and"s """
    finalstring = "["
    loweredstring = string.lower()
    exclude = '!"#$%&'()*+-./:;<=>?@[\]^_`{|}~'
    for c in exclude:
        loweredstring = loweredstring.replace(c,"")    
    for ch in loweredstring:
        if ch == ' ':
            finalstring = finalstring + ","
        elif ch == ',':
            finalstring = finalstring + ",comma"
        #elif ch == u'xb0' or ch == '°':
        #    finalstring = finalstring + ",degrees"
        else:
            finalstring = finalstring + ch
    return finalstring + "]"
        
def parse(inStr):
    """parse(str) -- cleans the user input and then throws it at Prolog for analysis"""
    codeOut = "null"
    sentence = strClean(inStr)
    prologCall = 'parseToCode(' + sentence + ', Status, CodeOut).'
    for soln in prolog.query(prologCall, maxresult=1):
        statusOut = ''.join(soln["Status"])
        if statusOut == 'valid':
            codeOut = buildMultiCode(soln["CodeOut"])
    return PrologResult(prologCall,statusOut,codeOut)
 
def buildCode(prologterms):
    """converts a [instruction, param1, param2, ...] list into Python-exec-friendly "instruction(param1,param2,...)" functor format"""
    parameters = [str(item) for item in prologterms]
    if len(parameters) > 2:
        codeOut = parameters[0] + '('
        for x in range(len(parameters)-2):
            codeOut = codeOut + parameters[x+1] + ', '
        codeOut = codeOut + parameters[len(parameters)-1] + ')'
    elif len(parameters) == 2:
        codeOut = parameters[0] + '(' + parameters[1] + ')'
    else:
        codeOut = parameters[0] + '()'
    return codeOut
 
def buildMultiCode(instructions):
    """converts a list of [instruction, param1, param2] codes into a list of Python-exec-friendly "instruction(param1,param2,...)" strings
       i.e. buildMultiCode([('forward',['1.0','3.0']),('stop',[])]) -> ['forward(1.0, 3.0)', 'stop()']"""
    multiCodeOut = []
    for x in instructions:
        line = buildCode(x)
        multiCodeOut.append(line)
    return multiCodeOut
 
 
def execute(code):       # potential security concerns here!
    """executes multiple lines of python script in sequence"""
    for line in code:
        if type(line) is list:
            execute(line)
        else:
            exec line
 
def toggle_inputMode(mode):
    """toggles between text and voice mode"""
    if mode == "text":
        print "Now activating voice input."
        return "voice"
    else:
        print "Switching back to text-input mode."
        return "text"
 
def toggle_outputMode(mode):
    """toggles between text and voice mode"""
    if mode == "text":
        print "Now activating voice output."
        return "voice"
    else:
        print "Switching back to text-only output mode."
        return "text"
 
def toggle_debugMode():
    """toggles between debug mode being on/off"""
    if debug == "on":
        print "Disabling debug mode."
        return "off"
    else:
        print "Enabling debug mode."
        return "on"
 
# addon robot commands
def takePhoto(mode):
    """Take and display a photo in the specified color mode. 2=color(fast), 1=color, 0=gray"""
    if mode == 2:
        pic = takePicture("jpeg-fast")
    elif mode == 1:
        pic = takePicture("color")
    else:
        pic = takePicture("gray")
    show(pic,"Scribby Cam")
    return
 
def move_until_wall():
    """Repeatedly moves forward in small increments until wall is sensed"""
    while not wall():
        forward(1.0, 0.7)
    return
 
def moonwalk(time):
    """Moonwalk backwards for time"""
    while timeRemaining(time):
        forward(.25,.1)                         
        backward(1,.3)                          
 
# MAIN 
def main():
    # global variable references
    global debug
    global prolog
    global inputMode
    global outputMode
     
    # initialize the robot
    print "***************** ScribPro v" + verNum + " *****************"
    init(scribblerPort)                           
    print "Scribbler II found on bluetooth (" + scribblerPort + ")."
     
    # instantiation of Prolog interface
    prolog = Prolog()
    prolog.consult(prologFile)
    print "Prolog has been initialized."
    print "Loaded " + prologFile + " into SWI-Prolog!"
 
    print "Starting in " + inputMode + " input mode. ['voice' to toggle]"
    print "Starting in " + outputMode + " output mode. ['sound' to toggle]"
    print "*************************************************"
     
    # main routine
    while(1):
        # grab a line of input, either text or voice
        if inputMode == "voice":
            try:
                inStr = pyspeech.input("nAwaiting voice command. (Ctrl-C to enter text)")
                print "Voice command: " + inStr + "n"
            except KeyboardInterrupt:
                inStr = raw_input("Type in a command: ")
        else:
            inStr = raw_input("nEnter a command: ")
 
        # parse the input and behave appropriately
        if (inStr == 'quit' or inStr == 'exit'):
            print "Exiting..."
            exit(0)
        elif inStr == 'reload':
            newprolog = Prolog()
            newprolog.consult(prologFile)
            prolog = newprolog
            print "Reloaded " + prologFile + " into Prolog!"
        elif inStr == 'voice':
            inputMode = toggle_inputMode(inputMode)
        elif inStr == 'sound':
            outputMode = toggle_outputMode(outputMode)
        elif inStr == 'debug':
            debug = toggle_debugMode()
        else:
            Result = parse(inStr)
            if Result.status == 'valid':
                if outputMode == "voice":
                    pyspeech.say("Okay")
                print "Okay."
                execute(Result.pythoncode)
            else:
                if outputMode == "voice":
                    errorMsg = "I don't understand " + inStr
                    pyspeech.say(errorMsg)
                print "I don't understand "" + inStr + ""."
                     
            # Print detailed debug information
            if debug == "on":   
                print "nProlog query executed:", Result.prologcall
                print "Status:", Result.status
                print "CodeOut:", Result.pythoncode
 
if __name__ == "__main__":
    main()

Category: Uncategorized | Tags: code, python

Archive for June 29, 2013

Week 2 – Web Performance Fever

Week 1 – Getting My Feet Wet

Internship – Performance Engineering

Project Summary: Natural Language Processing With Prolog

nlp.pl

scribpro.py

Recent Posts

Archives

Categories

Meta