def set_env(self, key, value, pre=False): """ Set an environment variable that is propigated to every frame. @type key: str @param key: Name of environement variable. @type value: str @param value: Value to associate with the name. @type pre: boolean @param pre: If this value is set to true, the environement variable is applied pre-setshot. The default is for the environment variable to be set post set shot. """ if self.__env.has_key(key): logger.warn("Overwriting outline env var: %s, from %s to %s", key, self.__env[key], value) if not isinstance(key, (str)): raise OutlineException("Invalid key type for env var: %s", type(key)) if not isinstance(value, (str)): raise OutlineException("Invalid value type for env var: %s", type(value)) self.__env[key] = (value, pre)
def load_json(json): """ Parse a json repesentation of an outline file. @type json: str @param json: A json string. @rtype: L{Outline} @return: The resulting outline object. """ def decode_layer(layer): """ Python 2.5.1 doesn't accept unicode strings as keyword arguments in class constructors. For this reason, they must be converted to byte strings. """ result = { } for k, v in layer.iteritems(): result[str(k)] = v del result["module"] del result["name"] return result data = simplejson.loads(json) ol = Outline(current=True) if data.has_key("name"): ol.set_name(data["name"]) if data.has_key("range"): ol.set_frame_range(data["range"]) for layer in data["layers"]: try: # Get the fully qualified module name, foo.bar.blah s_module = ".".join(layer["module"].split(".")[0:-1]) # Get the class to instantiated. s_class = layer["module"].split(".")[-1] # Import the module and instantiate the class. module = __import__(s_module, globals(), locals(), [s_class]) cls = getattr(module, s_class) cls(layer["name"], **decode_layer(layer)) except KeyError: error = "Json error, layer missing 'name' or 'module' definition" raise OutlineException(error) except Exception, e: msg = "Failed to load plugin: %s , %s" raise OutlineException(msg % (s_class, e))
def add_layer(self, layer): """Adds a new layer.""" if not layer.get_arg("register"): return if layer in self.__layers: logger.info("The layer %s was already added to this outline." % layer.get_name()) return if self.is_layer(layer.get_name()): raise OutlineException("The layer %s already exists" % layer.get_name()) self.__layers.append(layer) layer.set_outline(self) layer.after_init(self) try: if getattr(layer, "get_children"): for child in layer.get_children(): child.set_outline(self) child.after_init(self) except AttributeError: pass # If we're in setup mode, run setup ASAP if self.__mode == constants.OUTLINE_MODE_SETUP: layer.setup() logger.info("adding layer: %s" % layer.get_name())
def get_layer(self, name): """Return an later by name.""" layer_map = dict([(evt.get_name(), evt) for evt in self.__layers]) try: return layer_map[name] except Exception, e: raise OutlineException("invalid layer name: %s, %s" % (name, e))
def remove_layer(self, layer): """Remove an existing layer.""" if self.__mode >= constants.OUTLINE_MODE_SETUP: msg = "Cannot remove layers to an outline not in init mode." raise OutlineException(msg) if layer in self.__layers: self.__layers.remove(layer)
def load_session(self): """ Reloads the session """ if is_session_path(self.get_path()): self.__session = Session(self) else: msg = "failed to load outline %s, not part of a session." raise OutlineException(msg % self.get_path())
def parse_outline_script(path): """ Parse a native outline script and add any layers to the current outline's layer list. The current outline is optionally set when an outline oject is created by passing current=True to the constructor. Once the current outline is set, you can execute as many outline scripts as you want and the resulting layers become part of the current outline. @type path: str @param path: The path to the outline file. """ try: logger.info("parsing outline file %s" % path) execfile(path, {}) except Exception, exp: logger.warn("failed to parse as python file, %s" % exp) raise OutlineException("failed to parse outline file: %s, %s" % (path, exp))
def load_outline(path): """ Load an outline script. The path can be either an outline script or serialized outline script. @type path: str @param path: The path to the outline file. Serialized outline files must be named with the .yaml extension. Anything else is considered a python outline script. @rtype: L{Outline} @return: The resutling Outline object. """ logger.info("loading outline: %s" % path) # The wan cores may not see this file right away # The avere cache will hold a negative cache for 30 seconds, extending every time it is checked # The local cache will cache for 30 seconds as well if path and not os.path.exists(path): logger.info( 'Outline file does not exist, sleeping 35 seconds before checking again due to possible file cache latency.' ) time.sleep(35) ext = os.path.splitext(path) if ext[1] == ".yaml" or path.find("cue_archive") != -1: ol = yaml.load(file(path, 'r')) Outline.current = ol if not isinstance(ol, Outline): raise OutlineException("The file %s did not produce " "an Outline object." % path) else: # If the file is not .yaml, assume its a python script ol = Outline(path=path, current=True) # If the script is inside of a session if is_session_path(path): ol.load_session() return ol
def get_arg(self, key, default=None): """ Return the value assoiciated with the given key. Throw an OutlineException if the key does not exist. If a default value is provided then that value is returned instead of throwing an OutlineException. If the default value is None, an OutlineException is thrown. @type key: string @param key: The name of the argument. @rtype: mixed @return: The value associated with the given key. """ try: if default == None: return self.__args.get(key) else: return self.__args.get(key, default) except KeyError: raise OutlineException("No arg mapping exists for the value %s", key)
def set_mode(self, mode): """Set the current mode of the outline.""" if mode < self.__mode: raise OutlineException("You cannot go back to previous modes.") self.__mode = mode
def setup(self): """ Sets up the outline to run frames. A new session is created for the outline and setup() methods are run for each layer. - Creates a new session - Checks require arguments on all layers. - Runs tge setup() method for all layers. - Serializes outline structure into the session. - Sets the outline state to READY. """ if self.__mode >= constants.OUTLINE_MODE_SETUP: raise OutlineException("This outline is already setup.") self.setup_depends() self.__mode = constants.OUTLINE_MODE_SETUP self.__session = Session(self) # Run setup() for every layer assuming the frame range # can be determined. If there is no frame range, the layer # is not going to be launched to the cue. for layer in self.__layers: if layer.get_frame_range(): layer.setup() # Remove self from the current outline. if Outline.current == self: Outline.current = None if self.__serialize: yaml_file = os.path.join(self.__session.get_path(), "outline.yaml") # Set a new path before serialzing the outline file. logger.info("setting new outline path: %s" % yaml_file) self.set_path(yaml_file) # Copy the session over to a local variable and unset # self.__session. We do not want the session to be # archived with the outline because relaunching the # job using the serialized outline will fail. session = self.__session self.__session = None # Now copy outline file in. logger.info("serializing outline script to session path.") session.put_data(os.path.basename(yaml_file), self) # Switch the session back in. self.__session = session elif not self.__serialize and self.get_path(): logger.info("copying outline script to session path.") self.__session.put_file(self.get_path(), None, "script.outline") else: raise OutlineException("Failed to serialize outline, " "Procedural outlines must always " "use serialization.") # Set our new mode and save. self.set_mode(constants.OUTLINE_MODE_READY) self.__session.save()