import os

def echo(*l):
   for s in l:
      print s,
   print

def list_files(directory = "."):
   return os.listdir(directory)

$ import test
$ test:echo hello world
hello world
$ from test
$ echo thanks for all the fish
thanks for all the fish
$ echo (list_files)
['test.pyc', 'test.py', 'harpy.py']
$ echo (list_files).__len__
<method-wrapper object at 0xb7c1404c>
$ echo ((list_files).__len__)
3
$ echo (list_files /)
['bin', 'dev', 'etc', 'lib', 'mnt', 'opt', 'srv', 'tmp', 'sys', 'var', 'usr',
'.dev', 'boot', 'home', 'proc', 'sbin', 'root', 'cdrom', 'media',
'initrd.img', 'initrd', 'vmlinuz']

# Harpy 0.1 (jreeves@monkeyengines.co.uk)
import sys
import readline
import traceback

from pyparsing import *

def evaluate(expression):
   if hasattr(expression, '__eval__'):
      return expression.__eval__()
   else:
      return expression

class Interpreter:

   def __init__(self, namespace = {}):
      self.parse = self.__parser__()
      
      self.__namespace__ = namespace
      self.__namespace__['__interpreter__'] = self
      self.__namespace__.update(self.__builtins__())


   def load_module(self, name):
      module = __import__(name).__dict__
      try:
         module.update(module['__namespace__'])
      except KeyError:
         pass
      return module


   def __builtins__(self):
      def import_module(name):
         self.__namespace__[name] = self.load_module(name)

      def from_module(name, members = []):
         module = self.load_module(name)
         if members == []:
            self.__namespace__.update(module)
         else:   
            for member in members:
               self.__namespace__[member] = module[member]
               
      return { 'import' : import_module, 'from' : from_module }

   
   class Command:
      def __init__(self, namespace, element):
         self.namespace = namespace
         self.element   = element

      def __eval__(self):
         command = evaluate(self.element[0])
         if type(command) is str:
            command = self.namespace[command]
            
         for value in self.element[1:]:
            command = evaluate(getattr(command, value))
         return command

   
   class Argument:
      def __init__(self, element):
         self.element = element

      def __eval__(self):
         element = evaluate(self.element[0])
         for value in self.element[1:]:
            element = evaluate(getattr(element, value))

         return element
   
   
   class List:
      def __init__(self, head, tail):
         self.command   = head
         self.arguments = tail

      def __eval__(self):
         return evaluate(self.command)(
            *[evaluate(arg) for arg in self.arguments])
   
   
   def __parser__(self):      
      word  = CharsNotIn('"\'(): \n')
      quote = quotedString
      atom  = word | quote

      list     = Forward()
      molecule = Suppress('(') + list + Suppress(')')
      object   = atom | molecule
      
      expression = object + ZeroOrMore(Suppress(':') + atom)

      head = Empty() + expression
      tail = ZeroOrMore(expression)

      list << head + tail
      
      line = StringStart() + list + StringEnd()
      line.ignore("#" + restOfLine)

      def action(function):
         def wrapper(string, location, tokens):
            return function(tokens)
         return wrapper

      def quote_action(tokens):
         return [tokens[0][1:-1]]

      def head_action(tokens): 
         return self.Command(self.__namespace__, tokens[0])

      def tail_action(tokens):
         return [[self.Argument(t) for t in tokens]]
         
      def list_action(tokens):
         return self.List(tokens[0], tokens[1])
      
      def expression_action(tokens):
         return [tokens.asList()]

      quote.setParseAction( action(quote_action) )
      head.setParseAction( action(head_action) )
      tail.setParseAction( action(tail_action) )
      list.setParseAction( action(list_action) )
      expression.setParseAction( action(expression_action) )

      def parser(string):
         return line.parseString(string)[0]

      return parser


   def prompt(self):
      if not sys.stdin.isatty():
         return ""
      else:
         return "$ "


   def interact(self):
      while True:
         try:
            line = raw_input(self.prompt())
         except EOFError:
            break
            
         self.push(line)


   def push(self, line):
      try:
         parse_tree = self.parse(line)
         evaluate(parse_tree)
      except:
         traceback.print_exc()


if __name__ == '__main__':
   shell = Interpreter()
   shell.interact()