processor.py

Go to the documentation of this file.

"""
Defines the Processor class, which defines how to create targets from their
sources.
"""
 
import os
#import processing_rules
#import subprocess
import sys
 
__author__ = 'melliott'
 
class Processor(object):
    """
    Processor contains the data and methods needed to create a single target.
    """
    __name__ = "Processor"
    #def __init__(self, instr, src, ruleset, target_type, targt=''):
    def __init__(self, sensor, ruleset, program, par_data, out_dir):
 
        self.input_file = None
        self.geo_file = None
        self.par_data = par_data
        self.sensor = sensor
        self.target_type = program
        self.ocssw_root = os.environ['OCSSWROOT']
        self.ocssw_bin = os.environ['OCSSW_BIN']
        self.rule_set = ruleset
        self.applicable_rules = self._get_applicable_rules(ruleset)
        if 'odir' in par_data:
            self.out_directory = par_data['odir']
        else: 
            self.out_directory = out_dir
        if 'ofile' in par_data:
            self.output_file = par_data['ofile']
        else:
            self.output_file = ''
        # if 'deletefiles' in par_data:
        #     self.deletefiles = par_data['deletefiles']
        # else: 
        #     self.deletefiles = False
 
        self.required_types = self._find_required_types()
 
    def __cmp__(self, other):
        """
        Custom comparator to determine which Processor should come before another.
        This is based on the order in which they should be processed.
        """
        self_ndx = self.rule_set.order.index(self.target_type)
        if self_ndx < 0:
            print('Error!  Could not locate {0} target type in {1} rule set.'.format(self.target_type, str(self)))
            sys.exit(99)
#        other_ndx = other.rule_set.find_target_type(other.target_type)
        other_ndx = other.rule_set.order.index(other.target_type)
        if other_ndx < 0:
            print('Error!  Could not locate {0} target type in {1} rule set.'.format(other.target_type, str(other)))
            sys.exit(98)
        if self_ndx < other_ndx:
            return -1
        elif self_ndx > other_ndx:
            return 1
        else:
            return 0
 
    def __eq__(self, other):
        return self.__cmp__(other) == 0
    
    def __lt__(self, other):
        return self.__cmp__(other) < 0
        
    def __le__(self, other):
        return self.__cmp__(other) <= 0
    
    def __ne__(self, other):
        return self.__cmp__(other) != 0
    
    def __gt__(self, other):
        return self.__cmp__(other) > 0
    
    def __ge__(self, other):
        return self.__cmp__(other) >= 0
    
    def _find_required_types(self):
        req_types = self.rule_set.rules[self.target_type][1]
        return req_types
 
    def _get_applicable_rules(self, ruleset):
        applicable_rules = []
        ndx = 0
        # end_fnd = False
#        while (ndx < len(ruleset.rules)) and (not end_fnd):
        for targ in ruleset.order:
            if (self.target_type == targ):
                break
            else:
                applicable_rules.append(ruleset.rules[targ])
                ndx += 1
#        print "applicable_rules for %s: %s" % (str(self), str([str(r) for r in applicable_rules]))
        return applicable_rules
 
    def inputs_exist(self):
        """
        Return True if the inputs needed for the target output exist,
        otherwise return False.
        """
        input_file = ''
        if 'ifile' in self.par_data:
            input_file = self.par_data['ifile']
        return os.path.exists(input_file)
 
    def __repr__(self):
        return "Processor for target_type = {0}".format(self.target_type)
 
    def __str__(self):
        return "{0} processor".format(self.target_type)
 
    def execute(self):
        """
        Call the function to run the command for this Processor.
        """
        status = self.rule_set.rules[self.target_type].action(self)
        return status
 
    def requires_batch_processing(self):
        return self.rule_set.rules[self.target_type].requires_batch