Python Reporter.report方法代码示例

# 需要导入模块: from reporter import Reporter [as 别名]
# 或者: from reporter.Reporter import report [as 别名]
def main(args):
    if args.v:
        print args

    genes = read_genes(args)
    if args.v:
        print "%d genes" % len(genes)

    reporter = Reporter(Host(), genes)

    try:
        out = open(args.out_fn, "w")
    except IOError:
        out = sys.stdout
    except TypeError:
        out = sys.stdout

    out.write(reporter.report())
    for k in sorted(reporter.stats.keys()):
        out.write("%-20s: %s\n" % (k, reporter.stats[k]))

    if out != sys.stdout:
        out.close()

    return 0

# 需要导入模块: from reporter import Reporter [as 别名]
# 或者: from reporter.Reporter import report [as 别名]
class PuddingLogger(object):

    CHECK_UOP_INTERVAL = 5000

    def __init__(self, publisher=NoOpPublisher(), next_logger=None, site_count=6):
        super(PuddingLogger, self).__init__()
        self.duts = [PuddingUUT(i) for i in range(site_count)]
        gh_station = IPGHStation()
        s_type = gh_station[pypudding.IP_STATION_TYPE]
        station_id = gh_station[pypudding.IP_STATION_NUMBER]
        self.station_type = s_type
        self.station_id = station_id
        self.publisher = publisher
        self.next_logger=next_logger
        self.pivot_logger = None
        self.reporter = Reporter(self.publisher)
        self.check_uop_at = time.time() + self.CHECK_UOP_INTERVAL

    def check_UOP(self, site, force=False):
        if not force and self.duts[site].uut.sn:
            if time.time()<self.check_uop_at:
                return
            else:
                self.check_uop_at = time.time() + self.CHECK_UOP_INTERVAL
        try:
            uut = self.duts[site].uut
            if uut is not None:
                uut.amIOkay()
        except InstantPuddingError as e:
            self.reporter.report(events.REPORT_ERROR, site=site, error_code=reporter.FATAL_ERROR, error_msg=e.message)

    def zip_logs(self, log_files, ts, log_folder, sn):
        if len(log_files) == 0:
            return None
        dst = os.path.join(log_folder, sn)
        if os.path.exists(dst):
            shutil.rmtree(dst)
        os.mkdir(os.path.join(log_folder, sn))
        zf_path = os.path.join('/tmp', str(sn)+'_' + ts + '_'+'.zip')
        files = []
        for log_path in log_files:
            files.extend(get_all_files(log_path))
        if len(files)==0:
            return None
        zf = zipfile.ZipFile(zf_path, 'w')
        for file in files:
            f_name = os.path.split(file)[1]
            f_name = sn + '_' + f_name
            dest = os.path.join(dst, f_name)
            shutil.copy(str(file), str(dest))
            zf.write(dest, arcname=os.path.join(sn,f_name), compress_type=zipfile.ZIP_DEFLATED)
        zf.close()
        return zf_path


    @call_next
    @check_pudding_exception
    def log_sequence_start(self, ts, site, report):
        ts = ts.replace(':', '_') #replace : with _ because file names don't like :
        site_dut = self.duts[site]
        old_uut = site_dut.uut
        if old_uut is not None:
            del old_uut
        uut = IPUUT()
        site_dut.log_file_name = '/tmp/site_' + str(site) + '_' + ts + '_' + '_pudding_upload.log'
        site_dut.log_file = open(site_dut.log_file_name, 'w+')
        uut.start()
        uut.set_DUT_position(self.station_id, site+1)
        uut.add_attribute(pypudding.IP_ATTRIBUTE_STATIONSOFTWARENAME, report.data['name'])
        uut.add_attribute(pypudding.IP_ATTRIBUTE_STATIONSOFTWAREVERSION, report.data['version'])
        site_dut.uut = uut
        #there is no need to check amI OKay yet because there is no serial number yet
        return

    @call_next
    @check_pudding_exception
    def log_item_start(self, ts, site, report):
        self.check_UOP(site)
        data = report.data
        self.publisher.publish('in item start: ' + str(data))
        spec = None
        if data['to_pdca']:
            spec = IPTestSpec(str(data['group']),
                              subtest_name=str(data['tid']),
                              limits={'low_limit': data['low'], 'high_limit': data['high']},
                              unit=str(data['unit']))
        else:
            spec = IPTestSpec(str(data['group']),
                              subtest_name=str(data['tid'])) #this kind of test might need to be reported to pudding because it's pass/fail
        old_spec = self.duts[site].current_spec
        if old_spec is not None:
            del old_spec
        self.duts[site].current_spec = spec
        self.publisher.publish('in item start, spec=' + str(spec))
        return

    @call_next
    @check_pudding_exception
    def log_item_finish(self, ts, site, report):
        self.check_UOP(site, force=True)
#.........这里部分代码省略.........

# 需要导入模块: from reporter import Reporter [as 别名]
# 或者: from reporter.Reporter import report [as 别名]
class _DCL(object):
    rules = ListRule()
    mods = {}
    facts = []

    # the abscence that the system founded
    resolved_absences = []

    def __init__(self):
        self.rules = ListRule()
        self.mods = {}
        self.facts = []

        self.resolved_absences = []
        self.violations = []

        # to be constructed on def init()
        self.reporter = None

    def mod(self, name_mod, *path_mods):
        self.mods[name_mod] = ModuleDef(name_mod, path_mods)

    def get_mod(self, name_mod):
        module = self.mods.get(name_mod, None)
        if not module:
            raise ModuleDefNotFound(name_mod)

        return module

    def the(self, mod_name, type_interaction, mod_target):
        self.rules.append(TheRule(self.get_mod(mod_name), type_interaction, self.get_mod(mod_target)))

    def only(self, mod_name, type_interaction, mod_target):
        self.rules.append(OnlyRule(self.get_mod(mod_name), type_interaction, self.get_mod(mod_target)))

    def init(self, report_file=None):
        from trace import set_listening

        set_listening()

        self.reporter = Reporter(report_file)

    def conclude(self):
        """
        Now we show the must rules not satisfied
        """
        from copy import deepcopy

        must_rules = self.rules.filter_must()
        abscences = []

        for must in must_rules:
            if must.constraint not in self.resolved_absences:
                abscences.append(must)

        if not abscences:
            return

        self.reporter.report(self.violations, abscences)

    def notify_fact(self, fact):
        rules = self.rules.filter_by_type(fact["type"])

        for rule in rules:
            try:
                rule.verify(fact)
            except DivergenceException as e:
                self.violations.append(e)
            except ResolvedAbsenceException as e:
                # stores to report on the end of the executing
                self.resolved_absences.append(e.rule)