Ejemplo n.º 1
0
    def test(self):
        r = Report()
        r.create_report(onweb=False)

        # test setter
        r.filename = "index.html"
        r.directory = "report"

        r._init_report()
Ejemplo n.º 2
0
 def name(self):
     name = Report.name(self)
     if self.configs:
         name += '-' + '+'.join(self.configs)
     if self.suite:
         name += '-' + '+'.join(self.suite)
     name += '-' + self.resolution[0]
     name += '-' + self.report_type
     return name
Ejemplo n.º 3
0
    def test_local(self):

        # here we test if a local template works and if
        # a name different from index.html works
        temp_filename = "example.html"
        with open(temp_filename, "w") as fin:
            fin.write("{{ test }}")
        try:
            r = Report(".", template_filename=temp_filename)
            r.jinja['test'] = 'youpi'
            r.create_report(onweb=False)
            with open("report/index.html", "r") as fin:
                data = fin.read() 
                assert data == 'youpi'
        except Exception:
            raise Exception
        finally:
            # cleanup
            os.remove(temp_filename)
Ejemplo n.º 4
0
    def test_local(self):

        # here we test if a local template works and if
        # a name different from index.html works
        temp_filename = "example.html"
        with open(temp_filename, "w") as fin:
            fin.write("{{ test }}")
        try:
            r = Report(".", template_filename=temp_filename)
            r.jinja['test'] = 'youpi'
            r.create_report(onweb=False)
            with open("report/index.html", "r") as fin:
                data = fin.read()
                assert data == 'youpi'
        except Exception:
            raise Exception
        finally:
            # cleanup
            os.remove(temp_filename)
Ejemplo n.º 5
0
    def test(self):
        r = Report()
        r.create_report(onweb=False)

        # test setter
        r.filename = "index.html"
        r.directory = "report"

        r._init_report()
Ejemplo n.º 6
0
    def __init__(self, parser=ReportArgParser(parents=[report_type_parser])):
        parser.add_argument('-c', '--configs', type=tools.csv,
            help='only use specified configurations (e.g. WORK-ou,WORK-yY). '
                 'If none specified, use all found configs')
        parser.add_argument('-s', '--suite', type=tools.csv,
            help=downward_suites.HELP)

        Report.__init__(self, parser)

        if self.configs:
            self.name_parts.append('+'.join(self.configs))
        if self.suite:
            self.name_parts.append('+'.join(self.suite))

        if self.suite:
            self.problems = downward_suites.build_suite(self.suite)
        else:
            self.problems = []

        def filter_by_problem(run):
            """
            If suite is set, only process problems from the suite,
            otherwise process all problems
            """
            return any(prob.domain == run['domain'] and
                       prob.problem == run['problem'] for prob in self.problems)

        def filter_by_config(run):
            """
            If configs is set, only process those configs, otherwise process
            all configs
            """
            return any(config == run['config'] for config in self.configs)

        filter_funcs = []
        if self.configs:
            filter_funcs.append(filter_by_config)
        if self.problems:
            filter_funcs.append(filter_by_problem)
        if filter_funcs:
            self.data.filter(*filter_funcs)
Ejemplo n.º 7
0
 def generateStatistics(self, currentBatch = None):
   chdirOrDie(self.dirStructure.resultsDir)
   report = Report(self, currentBatch)
   report.generateFullReport()
   if report.canCompile():
     print "Compiling report..."
     report.compile()
Ejemplo n.º 8
0
 def test_report_properties(self):
     role_counts = {
         'admin': 1,
         'manager': 3,
         'author': 5,
         'reviewer': 6,
         'visitor': 3
     }
     report = Report(user_count=10, document_count=3, user_count_by_roles=role_counts, import_count=0,
                     export_count=4)
     self.assertEqual(report.user_count, 10)
     self.assertEqual(report.document_count, 3)
     self.assertEqual(report.user_count_by_roles, role_counts)
     self.assertEqual(report.import_count, 0)
     self.assertEqual(report.export_count, 4)
    def __init__(self, parser=ReportArgParser()):
        parser.set_defaults(output_format='tex')
        parser.add_argument('focus', choices=SCORES,
                    help='the analyzed attribute (e.g. "expanded"). '
                        'The "attributes" parameter is ignored')
        parser.add_argument('--squeeze', action='store_true',
                            help='Use small fonts to fit in more data')
        parser.add_argument('--no-best', action='store_false',
                            dest='best_value_column',
                            help='Do not add a column with best known score')
        parser.add_argument('--page-size', choices=['a2', 'a3', 'a4'],
                            default='a4',
                            help='Set the page size for the latex report')
        Report.__init__(self, parser)

        self.extension = 'tex'
        self.name_parts.append(self.focus)

        self.focus_name = self.focus
        self.normalize = True

        self.score = 'score_' + self.focus
        if self.focus == 'coverage':
            self.focus = 'cost'
            self.score = 'coverage'
        elif self.focus == 'quality':
            self.focus = 'cost'
            self.score = 'quality'

        logging.info('Using score attribute "%s"' % self.score)
        logging.info('Adding column with best value: %s' %
                     self.best_value_column)

        # Get set of configs
        self.configs = tools.natural_sort(self.data.group_dict('config').keys())
        self.total_scores = self._compute_total_scores()
Ejemplo n.º 10
0
    elif args.ticket == 'check' and args.filename:
        tickets.ticket_files(args.filename)
    elif args.comment:
        package.post_comment(args.comment)
    elif args.verify and args.verify != 'verify' and not args.config and not args.query and not args.filename:
        package.single_ticket(args.verify, export)
    elif args.verify == 'verify' and args.config and args.query and not args.filename:
        package.multiple_tickets(args.config, args.query)
    elif args.verify == 'verify' and args.filename:
        package.host_list_verify(args.filename)
    elif args.filename and not args.verify:
        tickets.filename(args.filename)
    elif args.new:
        config.config_create(args.new)
    elif args.example == 'example':
        Example.example()
    else:
        jira_query = "None has been set"
        print(
            colored(
                "Wrong input! please use --help or --example to learn more about program",
                'red'))


config = Config()
package = Package()
tickets = Ticket()
report = Report()
if __name__ == '__main__':
    main()
Ejemplo n.º 11
0
 def test_report_creation(self):
     report = Report()
Ejemplo n.º 12
0
 def get_queryset(self, *args, **kwargs):
     return [i for i in Report.list()]
Ejemplo n.º 13
0
    def __init__(self, parser=ReportArgParser(parents=[report_type_parser])):
        parser.add_argument(
            '-c',
            '--configs',
            nargs='*',
            default=[],
            help=
            'planner configurations (if none specified, use all found configs)'
        )
        parser.add_argument(
            '-s',
            '--suite',
            nargs='*',
            default=[],
            help='tasks, domains or suites (if none specified, use whole suite)'
        )
        parser.add_argument('--res',
                            default='domain',
                            dest='resolution',
                            help='resolution of the report',
                            choices=['suite', 'domain', 'problem'])

        parser.add_argument('--filter', nargs='*', default=[],
                            help='filters will be applied as follows: ' \
                                'expanded:lt:100 -> only process if run[expanded] < 100')

        Report.__init__(self, parser)

        self.focus = None
        self.output = ''

        # For some attributes only compare commonly solved tasks
        self.commonly_solved_foci = [
            'expanded', 'generated', 'plan_length', 'search_time', 'total_time'
        ]
        info = 'Report only commonly solved problems for %s'
        info %= self.commonly_solved_foci
        self.add_info(info)

        self.problems = downward_suites.build_suite(self.suite)

        def filter_by_problem(run):
            """
            If suite is set, only process problems from the suite, 
            otherwise process all problems
            """
            if not self.problems:
                return True
            for problem in self.problems:
                if problem.domain == run['domain'] and problem.problem == run[
                        'problem']:
                    return True
            return False

        def filter_by_config(run):
            """
            If configs is set, only process those configs, otherwise process all configs
            """
            if not self.configs:
                return True
            for config in self.configs:
                if config == run['config']:
                    return True
            return False

        self.add_filter(filter_by_problem, filter_by_config)

        self.parse_filters()
Ejemplo n.º 14
0
def report(rtype):
    if not isinstance(rtype, int):
        return "Expected an integer value. Exiting"
    elif rtype == 1:
        repo = get_repos()
        report = Report(repo=repo).user_languages()
        return out2csv(report, '../reports/issue_contrib.csv')
    elif rtype == 2:
        pulls = get_prs()
        report = Report(pulls=pulls).pr_ratios()
        return out2csv(report, '../reports/open_closed_merged_prs.csv')
    elif rtype == 3:
        pulls = get_prs(state='closed')
        report = Report(pulls=pulls).pr_ratios()
        return out2csv(report, '../reports/closed_merged_prs.csv')
    elif rtype == 4:
        pulls = get_prs()
        report = Report(pulls=pulls).contribution_count()
        return out2csv(report,
                       '../reports/positive_negative_pr_contributions.csv')
    elif rtype == 5:
        pulls = get_prs()
        report = Report(pulls=pulls).repo_maintenance()
        return out2csv(report, '../reports/repo_maintenance.csv')
    elif rtype == 6:
        repo = get_repos()
        report = Report(repo=repo).open_issues()
        return out2csv(report, '../reports/issue_assignees.csv')
    elif rtype == 7:
        repo = get_repos()
        report = Report(repo=repo).issue_comments()
        return out2csv(report, '../closed_issue_comments.csv')
    elif rtype == 8:
        #This is a heavy computation. Limiting to 10 PRs, as we're analyzing each sentence
        #in each comment in a single PR
        pulls = get_prs(limit=100)
        report = Report(pulls=pulls).pr_sentiment()
        return out2csv(report, '../reports/sentiment_analysis.csv')
    elif rtype == 9:
        pulls = get_prs(limit=500)
        report = Report(pulls=pulls).pr_report()
        return out2csv(report, '../reports/pr_report_closed.csv')
    elif rtype == 10:
        repo = get_repos()
        pulls = get_prs(limit=50)
        report = Report(pulls=pulls, repo=repo).sentiment_repo_report()
        fname = '../reports/pr_sentiment_report.csv'
        if fexists(Path(fname)):
            return out2csv(report, '../reports/pr_sentiment_report.csv', "a")
        else:
            return out2csv(report, '../reports/pr_sentiment_report.csv', "w+")
    elif rtype == 12:
        pulls = get_prs(state='all', limit=100)
        report = Report(pulls=pulls).parse()
        return out2csv(report, '../reports/100_json_pulls.csv')
    return True
Ejemplo n.º 15
0
import mraa
import mqtt
import time
import string
import os
import json
from reports import Report
from threading import Timer
from datetime import datetime

import MonashAirSense_config as Conf

# fields = Conf.fields #Initiate shared variable
values = Conf.values  #Initiate shared variable
timestamp = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
local_report = Report('/root', timestamp[0], timestamp[1])


def upload_data():
    #After upload_data is first run, it is run again at the specified interval
    Timer(Conf.MQTT_interval, upload_data, ()).start()

    #Formats and sends data over MQTT
    timestamp = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
    pairs = timestamp.split(" ")
    values["meta"]["date"] = pairs[0]  #Date
    values["meta"]["time"] = pairs[1]  #Time
    values["meta"]["timestamp"] = time.time()
    msg = json.dumps(values)  #Convert to JSON for sending to server.
    #Initiate and send MQTT
    MQTT = mqtt.mqtt(Conf.MQTT_broker, Conf.MQTT_port,