[Pipet Devel] Front to middle, peep, and piper.

[J.W. Bizzaro]

deanne at density.biop.umich.edu wrote:
> 
> The tty thing, is just about reading input from the keyboard and returning
> the input from the python function. I found ttyio.py that only returns
> what you want the keyboard to return (it traps exceptions and also can be
> modified to transform inputted text into your own definitions).
> 
> Anyway, I need to figure out exactly what peep is going to be expecting in
> this input thing. Are we going to be doing all the text filtering at the
> layer of input, or is it going to be a free-for-all and the downunder
> going to sort it/handle exceptions? If so, then all the peep input is
> going to do is to read the text input and then return the character and
> wait for the next one, until a condition is reached. I can have a tree of
> input functions that read off one another?

I'm not sure we need exception checking at the character-by-character level,
except perhaps for arrow and delete keys.  The input layer shouldn't be
verifying commands, just passing a string of text on to the netherlands when
ENTER is pressed.

About commands, we need to come up with a list of them.  Unlike the Unix
command line, these commands are not programs.  They're more like FTP
commands, so we can start with the HELP command to list all of the others.

I can't give you a complete list of commands yet, because there's likely to be
more functionality to come.  I want Peep to do whatever Pied does, except with
text.

Here are some I can think of off-hand:

  connect [node] <node id> [pipe] <pipe id> [to] [node] <node id> [pipe] <pipe
id>
  disconnect [node] <node id> [pipe] <pipe id> [[from] [node] <node id> [pipe]
<pipe id>]
  list [nodes]
  change [network (or node)] <node id>
  select [node] <node id>
  deselect [node] <node id>
  view [interface] <node id>
  (also view with ability to set parameters)
  (also some execution commands)

Of course, [] means optional, and <> means variable.
<node id> can also be "." and ".."

So, we actually need a layer lower than the tty layer to evaluate the command
line.

> I need to know what i'm going to aim for next. I don't have a good idea of
> what peep needs to be doing. Should I start stripping gnu from stuff? And
> when should I start worrying about that?

Okay, so the command-line evaluator is next.  It'll be a while longer before
we see Peep come together, since I'd like Brad to implement abstraction from
the XML API he just wrote about.  Be patient :-)

Cheers.
Jeff
-- 
                      +----------------------------------+
                      |           J.W. Bizzaro           |
                      |                                  |
                      | http://bioinformatics.org/~jeff/ |
                      |                                  |
                      |        BIOINFORMATICS.ORG        |
                      |           The Open Lab           |
                      |                                  |
                      |    http://bioinformatics.org/    |
                      +----------------------------------+