Hey everyone,
I am recently looking into automating things quite a bit differently than i used to. And i am looking for input on how to best approach this.
As an example i’ll use a geometry conversion pipeline. Imagine incoming data in format .in and it needs to be converted to format .out.
While doing the conversion there might be an arbitrary amount of intermediate steps to be performed, ranging from small cleanups and
sanity checks to more complex tasks. So all in all we’ll end up with something like this:
.in files -> in-task-1 -> in-task-2 -> in-task-3 -> convert to .out file -> out-task-1 -> out-task-2 -> final .out file
Now currently this is implemented in a multi-step process. Let’s assume .in being Maya and .out being Max (in the end, it should not matter at all ideally).
So there currently would be a Maya toolset that performs in-tasks 1-3, then exports to an intermediate format. Then there would be a Max
toolset that imports the intermediate file, performs out-tasks 1 and 2 and saves as the final .out file.
Yes…this is cumbersome. Now to ease things in a quick and hacky way the scripts have been adopted to allow being run via cmdline instances
so there is no more user interaction. This has proven to be incredibly cumbersome in many many ways. Especially handling output (both errors or information)
is really bad and it is quite easy to have it run for an hour, offer no progress report whatsoever and not even produce a single output file because
an error is not catched properly.
In addition this setup is VERY specific to the involved apps. Doing the same thing for the other direction is pretty much a full re-write.
Now what i would like to do is have a standalone tool to manage the conversion. And depending on the in and out files it would launch the needed tool to the
background and remote control it. Ideally it would get life feedback from the app to be easily able to stop if an error occurred or the user wants to.
Also, I would like to save myself from having to implement all the needed functionality on the application side and then calling the methods via sockets, or
whatever. Ideally i’d have a kind of interactive session that i can send commands to (which would be application native commands) and get the proper
returns.
Now has anyone done something alike and has any recommendations? Using Pyro to wrap things? Using Sockets and blindly execute strings as commands?
Or using 0mq to do the very same?
Am eager for any input, even if it crushes my findings so far, keep em coming
Kind Regards,
Thorsten