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
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"kamaelia" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to
[email protected]
For more options, visit this group at
http://groups.google.com/group/kamaelia?hl=en
-~----------~----~----~----~------~----~------~--~---
