[Pypes-user] Pypes meet Axon ?

[Michael S. <spa...@gm...>]

Hi,


Just saw pypes pass through the PyPI RSS feed, and think it's really 
interesting/cool. Congratulations on getting a release out the door :-)

For the reason why I find it interesting, I'll let code do the talking, with 
some things I find interesting parallels... :-)

pype.component.py
   class Component(object): # stackless.tasklet based

Axon.Component.py
   class component(microprocess): # generator based

(we also have thread based)

pypes.component.py
       def __init__(self):
           self.inputs  = {'in' : [None, 'Default input port'] }
           self.outputs = {'out': [None, 'Default output port']}
           self._parameters = {}

Axon.Component.py
      Inboxes  = {"inbox" : "Default inbox for bulk data. Used in a pipeline
                                much like stdin",
                  "control" : "Secondary inbox often used for signals. The
                         closest analogy is unix signals"
              }

      Outboxes = {"outbox": "Default data out outbox, used in a pipeline much
                                       like stdout",
                  "signal": "The default signal based outbox - kinda like
                               stderr,but more for sending singal type
                               signals",
                 }
      def __init__(self, *args, **argd):
         """(subclass always calls this via something like this:
         super(component, self).__init__()
         self.__dict__.update(argd)
         self.inboxes = dict()
         self.outboxes = dict()
         for boxname in self.Inboxes:
             self.inboxes[boxname] = makeInbox(notify=self.unpause)
         for boxname in self.Outboxes:
             self.outboxes[boxname] = makeOutbox(notify=self.unpause)

....
pypes.component.py
       def recv(self, port):

Axon.Component.py
      def recv(self,boxname="inbox"):

pypes.component.py
       def send(self, port, data):

Axon.Component.py
      def send(self,message, boxname="outbox"):

pypes.component.py
      def recvall(self, port):

Axon.Component.py
      def Inbox(self, boxname="inbox"):

You'll see further equivalences between Axon.Box.py and pype.py

Clearly we have some similar thinking here, and I must also say that your 
visual design programme is very shiny, and similar to our Compose tool, which 
is currently bust - so yours is by definition far nicer at the moment :-)

(Though it shares code with our pygame based run time visualiser which you
can see described here: http://www.kamaelia.org/AxonVisualiser )

Anyway some differences:
   -> You're using stackless tasklets & multiprocessing
   <- We're using standard generators, threads & pprocessing
   -> You appear to deny cyclic graphs. (I could be very wrong here though :)
   <- Many of our systems contain cycles.
   -> You appear to have been aware of J P Morrisons work before starting
   <- I wasn't . (starting points for me were occam, unix, hardware, etc)

Interesting to me:
   * I've wanted to switch from pprocessing to multiprocessing
   * I've been curious about supporting more forms of component,
      including stackless tasklets and greenlets for a while :-)
   * You also have a very shiny web based system editor, whereas our
      compose tool (which uses pygame & tkinter) is currently out of
      action :-)

ie figuring out some way of interoperating with Pypes strikes me as a really 
nice thing to do :) (The biggest "issue" I can see there is the switch around 
of port/box name & data really)

Anyway, I just wanted to say that pypes looks really neat & interesting, and 
congratulations on getting a release out! :-)

Good luck & have fun :)

:-)


Michael.
-- 
http://yeoldeclue.com/blog
http://twitter.com/kamaelian
http://www.kamaelia.org/Home