Exemple #1
0
 def wrapped(*args, **kwargs):
     statprof.start()
     try:
         return main(*args, **kwargs)
     finally:
         statprof.stop()
         statprof.display(OUT=file(output_file, 'wb'))
Exemple #2
0
      def stat():
         if options.profile:
            statprof.stop()

         output = StringIO.StringIO()
         output.write("-" * 80)
         output.write("\nWorker with PID %s processed %d requests\n"  % (workerPid, site.cnt))

         if options.profile:
            output.write("\n")
            #format = statprof.DisplayFormats.ByLine
            #format = statprof.DisplayFormats.ByMethod
            #statprof.display(output, format = format)
            statprof.display(output)

         output.write("-" * 80)
         output.write("\n")
         output.write("\n")

         sys.stdout.write(output.getvalue())

         if options.profile:
            statprof.reset()
            statprof.start()

         reactor.callLater(options.interval, stat)
Exemple #3
0
        def stat():
            if options.profile:
                statprof.stop()

            output = StringIO.StringIO()
            output.write("-" * 80 + "\n")
            output.write("Worker Statistics (PID %s)\n\n%s" %
                         (workerPid, factory.stats.stats()))

            if options.profile:
                output.write("\n")
                # format = statprof.DisplayFormats.ByLine
                # format = statprof.DisplayFormats.ByMethod
                # statprof.display(output, format = format)
                statprof.display(output)

            output.write("-" * 80 + "\n\n")

            sys.stdout.write(output.getvalue())

            if options.profile:
                statprof.reset(PROFILER_FREQ)
                statprof.start()

            reactor.callLater(options.interval, stat)
Exemple #4
0
 def wrapped(*args, **kwargs):
     statprof.start()
     try:
         return main(*args, **kwargs)
     finally:
         statprof.stop()
         statprof.display(OUT=file(output_file, 'wb'))
Exemple #5
0
        def stat():
            if options.profile:
                statprof.stop()

            output = StringIO.StringIO()
            output.write("-" * 80)
            output.write("\nWorker with PID %s processed %d requests\n" %
                         (workerPid, site.cnt))

            if options.profile:
                output.write("\n")
                #format = statprof.DisplayFormats.ByLine
                #format = statprof.DisplayFormats.ByMethod
                #statprof.display(output, format = format)
                statprof.display(output)

            output.write("-" * 80)
            output.write("\n")
            output.write("\n")

            sys.stdout.write(output.getvalue())

            if options.profile:
                statprof.reset()
                statprof.start()

            reactor.callLater(options.interval, stat)
Exemple #6
0
 def wrapped(*args, **kwargs):
     statprof.start()
     try:
         return fn(*args, **kwargs)
     finally:
         statprof.stop()
         statprof.display()
Exemple #7
0
 def inner(*args, **kwargs):
     statprof.reset(frequency=1000)
     statprof.start()
     try:
         return fn(*args, **kwargs)
     finally:
         statprof.stop()
         statprof.display()
Exemple #8
0
 def inner(*args, **kwargs):
     statprof.reset(frequency=1000)
     statprof.start()
     try:
         return fn(*args, **kwargs)
     finally:
         statprof.stop()
         statprof.display()
Exemple #9
0
 def catching(proc, *args, **kwargs):
     import statprof
     statprof.start()
     try:
         return proc(*args, **kwargs)
     finally:
         statprof.stop()
         statprof.display()
Exemple #10
0
def main():
    import argparse
    parser = argparse.ArgumentParser(description='volta console worker')
    parser.add_argument('-d',
                        '--debug',
                        '-v',
                        '--verbose',
                        dest='verbose',
                        action='store_true',
                        default=False)
    parser.add_argument('-t',
                        '--trace',
                        dest='trace',
                        action='store_true',
                        default=False)
    parser.add_argument('-q',
                        '--quiet',
                        dest='quiet',
                        action='store_true',
                        default=False)
    parser.add_argument('-l', '--log', dest='log', default='volta.log')
    parser.add_argument('-c', '--config', dest='config')
    parser.add_argument(
        '-p',
        '--patch-cfg',
        action='append',
        help=
        'Patch config with yaml snippet (similar to -o, but has full compatibility to\
        and the exact scheme of yaml format config)',
        dest='patches',
        default=[])
    parser.add_argument('--defaults',
                        dest='defaults',
                        default='/etc/volta.yaml')
    args = parser.parse_args()

    if not args.config:
        raise RuntimeError('Empty config')

    init_logging(args.log, args.verbose, args.quiet)
    configs = []
    try:
        configs = configs + [load_cfg(args.defaults)]
    except Exception:
        logger.info('Unable to load default configs... %s', args.defaults)
    configs = configs + [load_cfg(args.config)]

    if args.trace:
        import statprof
        statprof.start()

    patched_configs = configs + parse_and_check_patches(args.patches)
    perform_test(patched_configs, args.log)

    if args.trace:
        statprof.stop()
        statprof.display()
Exemple #11
0
def pilot_detail(request, pilot_id):
    return pilot_detail_view.pilot_detail(request, pilot_id)
    statprof.start()
    try:
        return pilot_detail_view.pilot_detail(request, pilot_id)
    finally:
        statprof.stop()
        statprof.display()
    return pilot_detail_view.pilot_detail(request, pilot_id)
    return render(request, "analizer/index.html", {"error_message": "Unsupported: "})
Exemple #12
0
def profile(fun, skip=False):
    """
    Statistical profiling of a given function.
    :param fun:
    :param skip:
    :return:
    """
    import statprof
    if skip:
        return fun()
    statprof.start()
    try:
        result = fun()
    finally:
        statprof.stop()
    statprof.display()
    return result
Exemple #13
0
 def inner(*args, **kwargs):
     if deco_kwargs.get('traceback'):
         traceback.print_stack()
     print('starting %s' % fn.__name__)
     start = time.time()
     stat_profile = deco_kwargs.get('stat_profile')
     if stat_profile:
         import statprof
         statprof.reset(frequency=10000)
         statprof.start()
     fn(*args, **kwargs)
     fn_time = time.time() - start
     print('finished %s in %s s' % (fn.__name__, fn_time))
     if stat_profile:
         statprof.stop()
         statprof.display()
     return fn_time
Exemple #14
0
def statprofile(ui, func, fp):
    try:
        import statprof
    except ImportError:
        raise util.Abort(_('statprof not available - install using "easy_install statprof"'))

    freq = ui.configint("profiling", "freq", default=1000)
    if freq > 0:
        statprof.reset(freq)
    else:
        ui.warn(_("invalid sampling frequency '%s' - ignoring\n") % freq)

    statprof.start()
    try:
        return func()
    finally:
        statprof.stop()
        statprof.display(fp)
Exemple #15
0
 def inner(*args, **kwargs):
     if deco_kwargs.get('traceback'):
         traceback.print_stack()
     print('starting %s' % fn.__name__)
     start = time.time()
     stat_profile = deco_kwargs.get('stat_profile')
     if stat_profile:
         import statprof
         statprof.reset(frequency=1000)
         statprof.start()
     try:
         return fn(*args, **kwargs)
     finally:
         fn_name = fn.__name__
         print('finished %s in %.3f s' % (fn_name, time.time() - start))
         if stat_profile:
             statprof.stop()
             statprof.display()
Exemple #16
0
def statprofile(ui, func, fp):
    try:
        import statprof
    except ImportError:
        raise util.Abort(_(
            'statprof not available - install using "easy_install statprof"'))

    freq = ui.configint('profiling', 'freq', default=1000)
    if freq > 0:
        statprof.reset(freq)
    else:
        ui.warn(_("invalid sampling frequency '%s' - ignoring\n") % freq)

    statprof.start()
    try:
        return func()
    finally:
        statprof.stop()
        statprof.display(fp)
Exemple #17
0
def run(main, profile=None):
    if not profile:
        main()
        return

    if profile == 'hotshot':
        import hotshot, hotshot.stats
        p = hotshot.Profile("/tmp/pro")
        p.runcall(main)
        p.close()
        hotshot.stats.load("/tmp/pro").sort_stats('cumulative').print_stats()
    elif profile == 'stat':
        import statprof
        statprof.start()
        try:
            main()
        finally:
            statprof.stop()
            statprof.display()
Exemple #18
0
 def inner(*args, **kwargs):
     log_fn = logger.debug
     if deco_kwargs.get('traceback'):
         traceback.print_stack()
     if deco_kwargs.get('traceback'):
         traceback.print_stack()
     log_fn('starting %s', fn.__name__)
     start = time.time()
     stat_profile = deco_kwargs.get('stat_profile')
     if stat_profile:
         import statprof
         statprof.reset(frequency=10000)
         statprof.start()
     try:
         return fn(*args, **kwargs)
     finally:
         log_fn('finished %s in %s s', fn.__name__, time.time() - start)
         if stat_profile:
             statprof.stop()
             statprof.display()
Exemple #19
0
def statprofile(ui, fp):
    try:
        import statprof
    except ImportError:
        raise error.Abort(_(
            'statprof not available - install using "easy_install statprof"'))

    freq = ui.configint('profiling', 'freq', default=1000)
    if freq > 0:
        # Cannot reset when profiler is already active. So silently no-op.
        if statprof.state.profile_level == 0:
            statprof.reset(freq)
    else:
        ui.warn(_("invalid sampling frequency '%s' - ignoring\n") % freq)

    statprof.start()
    try:
        yield
    finally:
        statprof.stop()
        statprof.display(fp)
Exemple #20
0
      def stat():
         if options.profile:
            statprof.stop()

         output = StringIO.StringIO()
         output.write("-" * 80 + "\n")
         output.write("Worker Statistics (PID %s)\n\n%s"  % (workerPid, factory.stats.stats()))

         if options.profile:
            output.write("\n")
            #format = statprof.DisplayFormats.ByLine
            #format = statprof.DisplayFormats.ByMethod
            #statprof.display(output, format = format)
            statprof.display(output)

         output.write("-" * 80 + "\n\n")

         sys.stdout.write(output.getvalue())

         if options.profile:
            statprof.reset(PROFILER_FREQ)
            statprof.start()

         reactor.callLater(options.interval, stat)
Exemple #21
0
def generateOrders():  # pylint: disable=invalid-name
    """Called once per turn to tell the Python AI to generate and issue orders to control its empire.
    at end of this function, fo.doneTurn() should be called to indicate to the client that orders are finished
    and can be sent to the server for processing."""

    rules = fo.getGameRules()
    print "Defined game rules:"
    for rule in rules.getRulesAsStrings:
        print "Name: " + rule.name + "  value: " + str(rule.value)
    print "Rule RULE_NUM_COMBAT_ROUNDS value: " + str(
        rules.getInt("RULE_NUM_COMBAT_ROUNDS"))

    empire = fo.getEmpire()
    if empire is None:
        print "This client has no empire. Doing nothing to generate orders."
        try:
            # early abort if no empire. no need to do meter calculations
            # on last-seen gamestate if nothing can be ordered anyway...
            #
            # note that doneTurn() is issued on behalf of the client network
            # id, not the empire id, so not having a correct empire id does
            # not invalidate doneTurn()
            fo.doneTurn()
        except Exception as e:
            print_error(e)
        return

    if empire.eliminated:
        print "This empire has been eliminated. Aborting order generation"
        try:
            # early abort if already eliminated. no need to do meter calculations
            # on last-seen gamestate if nothing can be ordered anyway...
            fo.doneTurn()
        except Exception as e:
            print_error(e)
        return

    # This code block is required for correct AI work.
    print "Meter / Resource Pool updating..."
    fo.initMeterEstimatesDiscrepancies()
    fo.updateMeterEstimates(False)
    fo.updateResourcePools()

    turn = fo.currentTurn()
    turn_uid = foAIstate.set_turn_uid()
    print "\n\n\n", "=" * 20,
    print "Starting turn %s (%s) of game: %s" % (turn, turn_uid,
                                                 foAIstate.uid),
    print "=" * 20, "\n"

    turn_timer.start("AI planning")
    # set the random seed (based on galaxy seed, empire name and current turn)
    # for game-reload consistency.
    random_seed = str(
        fo.getGalaxySetupData().seed) + "%05d%s" % (turn, fo.getEmpire().name)
    random.seed(random_seed)

    universe = fo.getUniverse()
    empire = fo.getEmpire()
    planet_id = PlanetUtilsAI.get_capital()
    planet = None
    if planet_id is not None:
        planet = universe.getPlanet(planet_id)
    aggression_name = get_trait_name_aggression(foAIstate.character)
    print "***************************************************************************"
    print "*******  Log info for AI progress chart script. Do not modify.   **********"
    print("Generating Orders")
    print(
        "EmpireID: {empire.empireID}"
        " Name: {empire.name}_{empire.empireID}_pid:{p_id}_{p_name}RIdx_{res_idx}_{aggression}"
        " Turn: {turn}").format(empire=empire,
                                p_id=fo.playerID(),
                                p_name=fo.playerName(),
                                res_idx=ResearchAI.get_research_index(),
                                turn=turn,
                                aggression=aggression_name.capitalize())
    print "EmpireColors: {0.colour.r} {0.colour.g} {0.colour.b} {0.colour.a}".format(
        empire)
    if planet:
        print "CapitalID: " + str(
            planet_id
        ) + " Name: " + planet.name + " Species: " + planet.speciesName
    else:
        print "CapitalID: None Currently Name: None Species: None "
    print "***************************************************************************"
    print "***************************************************************************"

    if turn == 1:
        declare_war_on_all()
        human_player = fo.empirePlayerID(1)
        greet = diplomatic_corp.get_first_turn_greet_message()
        fo.sendChatMessage(
            human_player, '%s (%s): [[%s]]' %
            (empire.name, get_trait_name_aggression(
                foAIstate.character), greet))

    # turn cleanup !!! this was formerly done at start of every turn -- not sure why
    foAIstate.split_new_fleets()

    foAIstate.refresh(
    )  # checks exploration border & clears roles/missions of missing fleets & updates fleet locs & threats
    foAIstate.report_system_threats()
    print("Calling AI Modules")
    # call AI modules
    action_list = [
        ColonisationAI.survey_universe,
        ProductionAI.find_best_designs_this_turn,
        PriorityAI.calculate_priorities,
        ExplorationAI.assign_scouts_to_explore_systems,
        ColonisationAI.assign_colony_fleets_to_colonise,
        InvasionAI.assign_invasion_fleets_to_invade,
        MilitaryAI.assign_military_fleets_to_systems,
        FleetUtilsAI.generate_fleet_orders_for_fleet_missions,
        FleetUtilsAI.issue_fleet_orders_for_fleet_missions,
        ResearchAI.generate_research_orders,
        ProductionAI.generate_production_orders,
        ResourcesAI.generate_resources_orders,
    ]

    for action in action_list:
        try:
            main_timer.start(action.__name__)
            action()
            main_timer.stop()
        except Exception as e:
            print_error(e, location=action.__name__)
    main_timer.stop_print_and_clear()
    turn_timer.stop_print_and_clear()
    turn_timer.start("Server_Processing")

    try:
        fo.doneTurn()
    except Exception as e:
        print_error(e)  # TODO move it to cycle above

    if using_statprof:
        try:
            statprof.stop()
            statprof.display()
            statprof.start()
        except:
            pass
Exemple #22
0
def generateOrders(): # pylint: disable=invalid-name
    "called by client to get the AI's orders for the turn"
    global _lastTurnTimestamp
    universe = fo.getUniverse()
    turnStartTime = time() #starting AI timer here, to be sure AI doesn't get blame for any  lags in server being able to provide the Universe object
    empire = fo.getEmpire()
    planetID = PlanetUtilsAI.getCapital()
    planet = None
    if planetID is not None:
        planet = universe.getPlanet(planetID)
    print "***************************************************************************"
    print "***************************************************************************"
    print ("Generating Orders")
    print "EmpireID:    " + str(empire.empireID) + " Name: " + empire.name+ "_"+str(empire.empireID) +"_pid:"+str(fo.playerID())+"_"+fo.playerName()+"_"+_aggressions.get(foAIstate.aggression,  "?") + " Turn: " + str(fo.currentTurn())
    empireColor = empire.colour
    print "EmpireColors: %d %d %d %d"% (empireColor.r,  empireColor.g,  empireColor.b,  empireColor.a)
    if planet:
        print "CapitalID: " + str(planetID) + " Name: " + planet.name + " Species: " + planet.speciesName
    else:
        print "CapitalID: None Currently      Name: None     Species: None "
    print "***************************************************************************"
    print "***************************************************************************"

    if fo.currentTurn() == 1:
        declareWarOnAll()

    # turn cleanup !!! this was formerly done at start of every turn -- not sure why
    splitNewFleets()

    #updateShipDesigns()   #should not be needed anymore;
    #updateFleetsRoles()

    foAIstate.clean() #checks exploration border & clears roles/missions of missing fleets & updates fleet locs
    foAIstate.reportSystemThreats()
    # ...missions
    # ...demands/priorities

    print("Calling AI Modules")

    # call AI modules
    timer = [time()]
    try:
        PriorityAI.calculatePriorities()
    except:
        print "Error: exception triggered and caught:  ",  traceback.format_exc() # try traceback.print_exc()
    timer.append( time()  )
    try:
        ExplorationAI.assignScoutsToExploreSystems()
    except:
        print "Error: exception triggered and caught:  ",  traceback.format_exc()
    timer.append( time()  )
    try:
        ColonisationAI.assignColonyFleetsToColonise()
    except:
        print "Error: exception triggered and caught:  ",  traceback.format_exc()
    timer.append( time()  )
    try:
        InvasionAI.assignInvasionFleetsToInvade()
    except:
        print "Error: exception triggered and caught:  ",  traceback.format_exc()
    timer.append( time()  )
    try:
        MilitaryAI.assignMilitaryFleetsToSystems()
    except:
        print "Error: exception triggered and caught:  ",  traceback.format_exc()
    timer.append( time()  )
    try:
        FleetUtilsAI.generateAIFleetOrdersForAIFleetMissions()
    except:
        print "Error: exception triggered and caught:  ",  traceback.format_exc()
    timer.append( time()  )
    try:
        FleetUtilsAI.issueAIFleetOrdersForAIFleetMissions()
    except:
        print "Error: exception triggered and caught:  ",  traceback.format_exc()
    timer.append( time()  )
    try:
        ResearchAI.generateResearchOrders()
    except:
        print "Error: exception triggered and caught:  ",  traceback.format_exc()
    timer.append( time()  )
    try:
        ProductionAI.generateProductionOrders()
    except:
        print "Error: exception triggered and caught:  ",  traceback.format_exc()
    timer.append( time()  )
    try:
        ResourcesAI.generateResourcesOrders()
    except:
        print "Error: exception triggered and caught:  ",  traceback.format_exc()
    timer.append( time()  )
    try:
        foAIstate.afterTurnCleanup()
    except:
        print "Error: exception triggered and caught:  ",  traceback.format_exc()
    timer.append( time()  )
    times = [timer[i] - timer[i-1] for i in range(1,  len(timer) ) ]
    turnEndTime = time()
    timeFmt = "%30s: %8d msec  "
    print "AI Module Time Requirements:"
    for mod,  modTime in zip(timerEntries ,  times):
        print timeFmt % ((30*' '+mod)[-30:],  int(1000*modTime))
    if _timerFile:
        _timerFile.write(  _timerFileFmt% tuple( [ fo.currentTurn() ]+map(lambda x: int(1000*x),  times )) +'\n')
        _timerFile.flush()
    if _timerBucketFile:
        _timerBucketFile.write(  _timerBucketFileFmt% tuple( [ fo.currentTurn(),  (turnStartTime-_lastTurnTimestamp)*1000, (turnEndTime-turnStartTime)*1000   ]) +'\n')
        _timerBucketFile.flush()
        _lastTurnTimestamp = time()

    try:
        fo.doneTurn()
    except:
        print "Error: exception triggered and caught:  ",  traceback.format_exc()

    if using_statprof:
        try:
            statprof.stop()
            statprof.display()
            statprof.start()
        except:
            pass
Exemple #23
0
def generateOrders():  # pylint: disable=invalid-name
    """Called once per turn to tell the Python AI to generate and issue orders to control its empire.
    at end of this function, fo.doneTurn() should be called to indicate to the client that orders are finished
    and can be sent to the server for processing."""
    turn_timer.start("AI planning")
    universe = fo.getUniverse()
    empire = fo.getEmpire()
    planet_id = PlanetUtilsAI.get_capital()
    # set the random seed (based on galaxy seed, empire ID and current turn)
    # for game-reload consistency
    random_seed = str(fo.getGalaxySetupData().seed) + "%03d%05d" % (
        fo.empireID(), fo.currentTurn())
    random.seed(random_seed)
    planet = None
    if planet_id is not None:
        planet = universe.getPlanet(planet_id)
    aggression_name = fo.aggression.values[foAIstate.aggression].name
    print "***************************************************************************"
    print "**********   String for chart. Do not modify.   ***************************"
    print("Generating Orders")
    print(
        "EmpireID: {empire.empireID}"
        " Name: {empire.name}_{empire.empireID}_pid:{p_id}_{p_name}RIdx_{res_idx}_{aggression}"
        " Turn: {turn}").format(empire=empire,
                                p_id=fo.playerID(),
                                p_name=fo.playerName(),
                                res_idx=ResearchAI.get_research_index(),
                                turn=fo.currentTurn(),
                                aggression=aggression_name.capitalize())
    print "EmpireColors: {0.colour.r} {0.colour.g} {0.colour.b} {0.colour.a}".format(
        empire)
    if planet:
        print "CapitalID: " + str(
            planet_id
        ) + " Name: " + planet.name + " Species: " + planet.speciesName
    else:
        print "CapitalID: None Currently Name: None Species: None "
    print "***************************************************************************"
    print "***************************************************************************"

    if fo.currentTurn() == 1:
        declare_war_on_all()
        human_player = fo.empirePlayerID(1)
        fo.sendChatMessage(
            human_player,
            '%s Empire (%s):\n"Ave, Human, morituri te salutant!"' %
            (empire.name, aggression_name))

    # turn cleanup !!! this was formerly done at start of every turn -- not sure why
    foAIstate.split_new_fleets()

    foAIstate.refresh(
    )  # checks exploration border & clears roles/missions of missing fleets & updates fleet locs & threats
    foAIstate.report_system_threats()
    # ...missions
    # ...demands/priorities
    print("Calling AI Modules")
    # call AI modules
    action_list = [
        PriorityAI.calculate_priorities,
        ExplorationAI.assign_scouts_to_explore_systems,
        ColonisationAI.assign_colony_fleets_to_colonise,
        InvasionAI.assign_invasion_fleets_to_invade,
        MilitaryAI.assign_military_fleets_to_systems,
        FleetUtilsAI.generate_fleet_orders_for_fleet_missions,
        FleetUtilsAI.issue_fleet_orders_for_fleet_missions,
        ResearchAI.generate_research_orders,
        ProductionAI.generateProductionOrders,
        ResourcesAI.generate_resources_orders,
        foAIstate.after_turn_cleanup,
    ]

    for action in action_list:
        try:
            main_timer.start(action.__name__)
            action()
            main_timer.stop()
        except Exception as e:
            print_error(e, location=action.__name__)
    main_timer.end()
    turn_timer.end()
    turn_timer.start("Server_Processing")

    try:
        fo.doneTurn()
    except Exception as e:
        print_error(e)  # TODO move it to cycle above

    if using_statprof:
        try:
            statprof.stop()
            statprof.display()
            statprof.start()
        except:
            pass
Exemple #24
0
def get_output(**kwargs):
    buffer = StringIO()
    display(buffer, **kwargs)
    buffer.seek(0)
    return buffer.read()
Exemple #25
0
def generateOrders():  # pylint: disable=invalid-name
    """Called once per turn to tell the Python AI to generate and issue orders to control its empire.
    at end of this function, fo.doneTurn() should be called to indicate to the client that orders are finished
    and can be sent to the server for processing."""
    empire = fo.getEmpire()
    if empire is None:
        print "This client has no empire. Doing nothing to generate orders."
        try:
            # early abort if no empire. no need to do meter calculations
            # on last-seen gamestate if nothing can be ordered anyway...
            #
            # note that doneTurn() is issued on behalf of the client network
            # id, not the empire id, so not having a correct empire id does
            # not invalidate doneTurn()            
            fo.doneTurn()
        except Exception as e:
            print_error(e)
        return
    
    if empire.eliminated:
        print "This empire has been eliminated. Aborting order generation"
        try:
            # early abort if already eliminated. no need to do meter calculations
            # on last-seen gamestate if nothing can be ordered anyway...
            fo.doneTurn()
        except Exception as e:
            print_error(e)
        return

    # This code block is required for correct AI work.
    print "Meter / Resource Pool updating..."
    fo.initMeterEstimatesDiscrepancies()
    fo.updateMeterEstimates(False)
    fo.updateResourcePools()

    turn = fo.currentTurn()
    turn_uid = foAIstate.set_turn_uid()
    print "\n\n\n", "=" * 20,
    print "Starting turn %s (%s) of game: %s" % (turn, turn_uid, foAIstate.uid),
    print "=" * 20, "\n"

    turn_timer.start("AI planning")
    # set the random seed (based on galaxy seed, empire name and current turn)
    # for game-reload consistency.
    random_seed = str(fo.getGalaxySetupData().seed) + "%05d%s" % (turn, fo.getEmpire().name)
    random.seed(random_seed)

    universe = fo.getUniverse()
    empire = fo.getEmpire()
    planet_id = PlanetUtilsAI.get_capital()
    planet = None
    if planet_id is not None:
        planet = universe.getPlanet(planet_id)
    aggression_name = get_trait_name_aggression(foAIstate.character)
    print "***************************************************************************"
    print "*******  Log info for AI progress chart script. Do not modify.   **********"
    print ("Generating Orders")
    print ("EmpireID: {empire.empireID}"
           " Name: {empire.name}_{empire.empireID}_pid:{p_id}_{p_name}RIdx_{res_idx}_{aggression}"
           " Turn: {turn}").format(empire=empire,  p_id=fo.playerID(), p_name=fo.playerName(),
                                   res_idx=ResearchAI.get_research_index(), turn=turn,
                                   aggression=aggression_name.capitalize())
    print "EmpireColors: {0.colour.r} {0.colour.g} {0.colour.b} {0.colour.a}".format(empire)
    if planet:
        print "CapitalID: " + str(planet_id) + " Name: " + planet.name + " Species: " + planet.speciesName
    else:
        print "CapitalID: None Currently Name: None Species: None "
    print "***************************************************************************"
    print "***************************************************************************"

    if turn == 1:
        declare_war_on_all()
        human_player = fo.empirePlayerID(1)
        greet = diplomatic_corp.get_first_turn_greet_message()
        fo.sendChatMessage(human_player, '%s (%s): [[%s]]' % (empire.name, get_trait_name_aggression(foAIstate.character), greet))

    # turn cleanup !!! this was formerly done at start of every turn -- not sure why
    foAIstate.split_new_fleets()

    foAIstate.refresh()  # checks exploration border & clears roles/missions of missing fleets & updates fleet locs & threats
    foAIstate.report_system_threats()
    print("Calling AI Modules")
    # call AI modules
    action_list = [ColonisationAI.survey_universe,
                   ProductionAI.find_best_designs_this_turn,
                   PriorityAI.calculate_priorities,
                   ExplorationAI.assign_scouts_to_explore_systems,
                   ColonisationAI.assign_colony_fleets_to_colonise,
                   InvasionAI.assign_invasion_fleets_to_invade,
                   MilitaryAI.assign_military_fleets_to_systems,
                   FleetUtilsAI.generate_fleet_orders_for_fleet_missions,
                   FleetUtilsAI.issue_fleet_orders_for_fleet_missions,
                   ResearchAI.generate_research_orders,
                   ProductionAI.generate_production_orders,
                   ResourcesAI.generate_resources_orders,
                   ]

    for action in action_list:
        try:
            main_timer.start(action.__name__)
            action()
            main_timer.stop()
        except Exception as e:
            print_error(e, location=action.__name__)
    main_timer.stop_print_and_clear()
    turn_timer.stop_print_and_clear()
    turn_timer.start("Server_Processing")

    try:
        fo.doneTurn()
    except Exception as e:
        print_error(e)  # TODO move it to cycle above

    if using_statprof:
        try:
            statprof.stop()
            statprof.display()
            statprof.start()
        except:
            pass
Exemple #26
0
import pstats
import sys

def parse_1kg():
    for line in vcf.Reader(filename='vcf/test/1kg.vcf.gz'):
        pass

if len(sys.argv) == 1:
    sys.argv.append(None)

if sys.argv[1] == 'profile':
    cProfile.run('parse_1kg()', '1kg.prof')
    p = pstats.Stats('1kg.prof')
    p.strip_dirs().sort_stats('time').print_stats()

elif sys.argv[1] == 'time':
    n = 1
    t = timeit.timeit('parse_1kg()',  "from __main__ import parse_1kg", number=n)
    print t/n

elif sys.argv[1] == 'stat':
    import statprof
    statprof.start()
    try:
        parse_1kg()
    finally:
        statprof.stop()
        statprof.display()
else:
    print 'prof.py profile/time'
Exemple #27
0
def stat_profiler():
    statprof.start()
    yield statprof
    statprof.stop()
    statprof.display()
def main():
    parser = argparse.ArgumentParser(
        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
        description=
        """Peppercorn: Domain-level nucleic acid reaction enumerator.""")
    add_peppercorn_args(parser)
    args = parser.parse_args()

    # ~~~~~~~~~~~~~
    # Logging Setup
    # ~~~~~~~~~~~~~
    title = "Peppercorn Domain-level Reaction Enumerator"
    logger = logging.getLogger('peppercornenumerator')
    logger.setLevel(logging.DEBUG)

    if args.logfile:
        banner = "{} {}".format(title, __version__)
        fh = logging.FileHandler(args.logfile)
        formatter = logging.Formatter('%(levelname)s - %(message)s')
        set_handle_verbosity(fh, args.verbose)
        fh.setFormatter(formatter)
        logger.addHandler(fh)
    else:
        banner = "{} {}".format(colors.BOLD + title + colors.ENDC,
                                colors.GREEN + __version__ + colors.ENDC)
        ch = logging.StreamHandler()
        formatter = ColorFormatter('%(levelname)s %(message)s', use_color=True)
        set_handle_verbosity(ch, args.verbose)
        ch.setFormatter(formatter)
        logger.addHandler(ch)

    logger.info(banner)

    assertions = False
    try:
        assert False
    except AssertionError:
        assertions = True
    logger.debug(f'Using assert statements: {assertions}.')

    systeminput = args.input_filename
    if not systeminput:
        if sys.stdout.isatty():
            logger.info("Reading file from STDIN, Ctrl-D to stop")
        systeminput = ''
        for l in sys.stdin:
            systeminput += l
        if args.interactive:
            loger.error(
                "Interactive mode needs to read input from file, not STDIN.")
            raise SystemExit

    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
    # Input parsing to set initial complexes for enumeration #
    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
    try:
        complexes, reactions = read_pil(systeminput, args.input_filename
                                        is not None)
    except ParseException as ex_pil:
        try:
            complexes, reactions = read_seesaw(systeminput,
                                               args.input_filename is not None,
                                               conc=args.seesaw_conc,
                                               explicit=args.seesaw_explicit,
                                               reactions=args.seesaw_reactions)
        except ParseException as ex_ssw:
            logger.error('Pil-format parsing error:')
            logger.error('Cannot parse line {:5d}: "{}"'.format(
                ex_pil.lineno, ex_pil.line))
            logger.error(
                '                          {} '.format(' ' * (ex_pil.col - 1) +
                                                       '^'))
            logger.error('SeeSaw-format parsing error:')
            logger.error('Cannot parse line {:5d}: "{}"'.format(
                ex_ssw.lineno, ex_ssw.line))
            logger.error(
                '                          {} '.format(' ' * (ex_ssw.col - 1) +
                                                       '^'))
            raise SystemExit

    init_cplxs = [
        x for x in complexes.values()
        if x.concentration is None or x.concentration[1] != 0
    ]
    name_cplxs = list(complexes.values())
    enum = Enumerator(init_cplxs, reactions, named_complexes=name_cplxs)

    # Log initial complexes
    logger.info("")
    logger.info("Initial complexes:")
    for c in enum.initial_complexes:
        logger.info("{}: {}".format(c, c.kernel_string))

    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
    # Transfer options to enumerator object #
    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
    logger.info("")
    logger.info("Enumeration settings:")
    enum.max_complex_size = args.max_complex_size
    logger.info("Max complex size = {}".format(enum.max_complex_size))
    enum.max_complex_count = max(args.max_complex_count, len(complexes))
    logger.info("Max complex count = {}".format(enum.max_complex_count))
    enum.max_reaction_count = max(args.max_reaction_count, len(reactions))
    logger.info("Max reaction count = {}".format(enum.max_reaction_count))
    enum.max_helix = not args.no_max_helix
    logger.info('Max-helix semantics = {}'.format(enum.max_helix))
    enum.reject_remote = args.reject_remote
    logger.info('Reject-remote semantics = {}'.format(enum.reject_remote))
    enum.dG_bp = args.dG_bp
    logger.info('Average strength of a toehold base-pair dG_bp = {}'.format(
        enum.dG_bp))
    if args.ignore_branch_3way:
        if branch_3way in UNI_REACTIONS:
            UNI_REACTIONS.remove(branch_3way)
        logger.info('No 3-way branch migration.')
    if args.ignore_branch_4way:
        if branch_4way in UNI_REACTIONS:
            UNI_REACTIONS.remove(branch_4way)
        logger.info('No 4-way branch migration.')
    PepperComplex.PREFIX = args.complex_prefix
    logger.info("Prefix for new complexes = {PepperComplex.PREFIX}")

    # Set either k-slow or release cutoff.
    if args.k_slow:
        if args.release_cutoff is not None:
            args.release_cutoff = None
            logger.warning('Release-cutoff overwritten by k-slow!')
        if args.release_cutoff_1_1 != args.release_cutoff_1_2:
            logger.warning('Release-cutoff (1,1) overwritten by k-slow!')
            logger.warning('Release-cutoff (1,2) overwritten by k-slow!')
        rc, k_rc = 0, None
        while True:
            rc += 1
            k_rc = opening_rate(rc)
            if k_rc < args.k_slow:
                break
        enum.release_cutoff = rc
        enum.k_slow = args.k_slow
        logger.info('Rate-dependent enumeration: k-slow = {}'.format(
            enum.k_slow))
        logger.info('  - corresponding release-cutoff: {} < L < {}'.format(
            rc - 1, rc))
    else:
        if args.release_cutoff is not None:
            enum.release_cutoff = args.release_cutoff
            logger.info(
                'Rate-independent enumeration: release cutoff L = {}'.format(
                    enum.release_cutoff))
            logger.info('  - corresponding k-slow: {}'.format(
                opening_rate(enum.release_cutoff)))
        else:
            logger.info("Rate-independent enumeration:")
            enum.release_cutoff_1_1 = args.release_cutoff_1_1
            logger.info(
                "  - release cutoff for reaction arity (1,1) = {}".format(
                    enum.release_cutoff_1_1))
            enum.release_cutoff_1_2 = args.release_cutoff_1_2
            logger.info(
                "  - release cutoff for reaction arity (1,2) = {}".format(
                    enum.release_cutoff_1_2))
    if args.k_fast:
        enum.k_fast = args.k_fast
        logger.info('Rate-dependent enumeration: k-fast = {}'.format(
            enum.k_fast))

    # DEBUGGING
    enum.DFS = not args.bfs
    enum.interactive = args.interactive
    enum.interruptible = args.interruptible

    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
    # Run reaction enumeration (or not) #
    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
    logger.info("")
    if args.profile:
        try:
            import statprof
        except ImportError as err:
            logger.warning(
                "Python-module statprof not found (pip install statprof-smarkets). Peppercorn profiling disabled."
            )
            args.profile = False

    if args.dry_run:
        logger.info("Dry run (not enumerating any reactions)... ")
        enum.dry_run()
        logger.info("Done.")
    else:
        logger.info("Enumerating reactions...")
        if args.interactive:
            logger.info("Interactive mode enabled: Fast and slow reactions " + \
                        "will be printed for each complex as enumerated." + \
                        "Press ^C at any time to terminate and write accumulated" + \
                        "complexes to output.")
        if args.profile:
            statprof.start()
            try:
                enum.enumerate()
            finally:
                statprof.stop()
                statprof.display()
        else:
            enum.enumerate()
        logger.info("Done.")

    # ~~~~~~~~~~~~~~~~~~~ #
    # Handle condensation #
    # ~~~~~~~~~~~~~~~~~~~ #
    condensed = args.condensed
    detailed = (not args.condensed or args.detailed)
    if condensed:
        logger.info("Output will be condensed to remove transient complexes.")
        if args.profile:
            statprof.start()
            try:
                enum.condense()
            finally:
                statprof.stop()
                statprof.display()
        else:
            enum.condense()

    if args.sbml:
        if detailed and condensed:
            logger.error("SBML output can be detailed OR condensed, not both.")
        enum.to_sbml(args.sbml, condensed=condensed)

    output = enum.to_pil(args.output_filename,
                         detailed=detailed,
                         condensed=condensed,
                         molarity=args.concentration_unit,
                         time=args.time_unit)

    if output is not None:
        print(output, end='')
Exemple #29
0
 def stop_profiling():
     statprof.stop()
     statprof.display()
Exemple #30
0
def generateOrders():  # pylint: disable=invalid-name
    """Called once per turn to tell the Python AI to generate and issue orders to control its empire.
    at end of this function, fo.doneTurn() should be called to indicate to the client that orders are finished
    and can be sent to the server for processing."""
    try:
        rules = fo.getGameRules()
        debug("Defined game rules:")
        for rule_name, rule_value in rules.getRulesAsStrings().items():
            debug("%s: %s", rule_name, rule_value)
        debug("Rule RULE_NUM_COMBAT_ROUNDS value: " + str(rules.getInt("RULE_NUM_COMBAT_ROUNDS")))
    except Exception as e:
        error("Exception %s when trying to get game rules" % e, exc_info=True)

    empire = fo.getEmpire()
    if empire is None:
        fatal("This client has no empire. Doing nothing to generate orders.")
        try:
            # early abort if no empire. no need to do meter calculations
            # on last-seen gamestate if nothing can be ordered anyway...
            #
            # note that doneTurn() is issued on behalf of the client network
            # id, not the empire id, so not having a correct empire id does
            # not invalidate doneTurn()
            fo.doneTurn()
        except Exception as e:
            error("Exception %s in doneTurn() on non-existent empire" % e, exc_info=True)
        return

    if empire.eliminated:
        debug("This empire has been eliminated. Aborting order generation")
        try:
            # early abort if already eliminated. no need to do meter calculations
            # on last-seen gamestate if nothing can be ordered anyway...
            fo.doneTurn()
        except Exception as e:
            error("Exception %s while trying doneTurn() on eliminated empire" % e, exc_info=True)
        return

    # This code block is required for correct AI work.
    info("Meter / Resource Pool updating...")
    fo.initMeterEstimatesDiscrepancies()
    fo.updateMeterEstimates(False)
    fo.updateResourcePools()

    turn = fo.currentTurn()
    aistate = get_aistate()
    turn_uid = aistate.set_turn_uid()
    debug("\n\n\n" + "=" * 20)
    debug("Starting turn %s (%s) of game: %s" % (turn, turn_uid, aistate.uid))
    debug("=" * 20 + "\n")

    turn_timer.start("AI planning")
    # set the random seed (based on galaxy seed, empire name and current turn)
    # for game-reload consistency.
    random_seed = str(fo.getGalaxySetupData().seed) + "%05d%s" % (turn, fo.getEmpire().name)
    random.seed(random_seed)

    universe = fo.getUniverse()
    empire = fo.getEmpire()
    planet_id = PlanetUtilsAI.get_capital()
    planet = None
    if planet_id is not None:
        planet = universe.getPlanet(planet_id)
    aggression_name = get_trait_name_aggression(aistate.character)
    debug("***************************************************************************")
    debug("*******  Log info for AI progress chart script. Do not modify.   **********")
    debug("Generating Orders")
    debug("EmpireID: {empire.empireID}"
          " Name: {empire.name}_{empire.empireID}_pid:{p_id}_{p_name}RIdx_{res_idx}_{aggression}"
          " Turn: {turn}".format(empire=empire, p_id=fo.playerID(), p_name=fo.playerName(),
                                 res_idx=ResearchAI.get_research_index(), turn=turn,
                                 aggression=aggression_name.capitalize()))
    debug("EmpireColors: {0.colour.r} {0.colour.g} {0.colour.b} {0.colour.a}".format(empire))
    if planet:
        debug("CapitalID: " + str(planet_id) + " Name: " + planet.name + " Species: " + planet.speciesName)
    else:
        debug("CapitalID: None Currently Name: None Species: None ")
    debug("***************************************************************************")
    debug("***************************************************************************")

    # When loading a savegame, the AI will already have issued orders for this turn.
    # To avoid duplicate orders, generally try not to replay turns. However, for debugging
    # purposes it is often useful to replay the turn and observe varying results after
    # code changes. Set the replay_after_load flag in the AI config to let the AI issue
    # new orders after a game load. Note that the orders from the original savegame are
    # still being issued and the AIstate was saved after those orders were issued.
    # TODO: Consider adding an option to clear AI orders after load (must save AIstate at turn start then)
    if fo.currentTurn() == aistate.last_turn_played:
        info("The AIstate indicates that this turn was already played.")
        if not check_bool(get_option_dict().get('replay_turn_after_load', 'False')):
            info("Aborting new order generation. Orders from savegame will still be issued.")
            try:
                fo.doneTurn()
            except Exception as e:
                error("Exception %s while trying doneTurn()" % e, exc_info=True)
            return
        else:
            info("Issuing new orders anyway.")

    if turn == 1:
        human_player = fo.empirePlayerID(1)
        greet = diplomatic_corp.get_first_turn_greet_message()
        fo.sendChatMessage(human_player,
                           '%s (%s): [[%s]]' % (empire.name, get_trait_name_aggression(aistate.character), greet))

    aistate.prepare_for_new_turn()
    turn_state.state.update()
    debug("Calling AI Modules")
    # call AI modules
    action_list = [ColonisationAI.survey_universe,
                   ProductionAI.find_best_designs_this_turn,
                   PriorityAI.calculate_priorities,
                   ExplorationAI.assign_scouts_to_explore_systems,
                   ColonisationAI.assign_colony_fleets_to_colonise,
                   InvasionAI.assign_invasion_fleets_to_invade,
                   MilitaryAI.assign_military_fleets_to_systems,
                   FleetUtilsAI.generate_fleet_orders_for_fleet_missions,
                   FleetUtilsAI.issue_fleet_orders_for_fleet_missions,
                   ResearchAI.generate_research_orders,
                   ProductionAI.generate_production_orders,
                   ResourcesAI.generate_resources_orders,
                   ]

    for action in action_list:
        try:
            main_timer.start(action.__name__)
            action()
            main_timer.stop()
        except Exception as e:
            error("Exception %s while trying to %s" % (e, action.__name__), exc_info=True)
    main_timer.stop_print_and_clear()
    turn_timer.stop_print_and_clear()

    debug('Size of issued orders: ' + str(fo.getOrders().size))

    turn_timer.start("Server_Processing")

    try:
        fo.doneTurn()
    except Exception as e:
        error("Exception %s while trying doneTurn()" % e, exc_info=True)  # TODO move it to cycle above
    finally:
        aistate.last_turn_played = fo.currentTurn()

    if using_statprof:
        try:
            statprof.stop()
            statprof.display()
            statprof.start()
        except:
            pass
Exemple #31
0
def train(config, level_name=None, timestamp=None, time_budget=None,
          verbose_logging=None, debug=None, profile=None):
    """
    Trains a given YAML file.

    Parameters
    ----------
    config : str
        A YAML configuration file specifying the
        training procedure.
    level_name : bool, optional
        Display the log level (e.g. DEBUG, INFO)
        for each logged message.
    timestamp : bool, optional
        Display human-readable timestamps for
        each logged message.
    time_budget : int, optional
        Time budget in seconds. Stop training at
        the end of an epoch if more than this
        number of seconds has elapsed.
    verbose_logging : bool, optional
        Display timestamp, log level and source
        logger for every logged message
        (implies timestamp and level_name are True).
    debug : bool, optional
        Display any DEBUG-level log messages,
        False by default.
    """
    train_obj = serial.load_train_file(config)
    try:
        iter(train_obj)
        iterable = True
    except TypeError:
        iterable = False

    # Undo our custom logging setup.
    restore_defaults()
    # Set up the root logger with a custom handler that logs stdout for INFO
    # and DEBUG and stderr for WARNING, ERROR, CRITICAL.
    root_logger = logging.getLogger()
    if verbose_logging:
        formatter = logging.Formatter(fmt="%(asctime)s %(name)s %(levelname)s "
                                          "%(message)s")
        handler = CustomStreamHandler(formatter=formatter)
    else:
        if timestamp:
            prefix = '%(asctime)s '
        else:
            prefix = ''
        formatter = CustomFormatter(prefix=prefix, only_from='pylearn2')
        handler = CustomStreamHandler(formatter=formatter)
    root_logger.addHandler(handler)
    # Set the root logger level.
    if debug:
        root_logger.setLevel(logging.DEBUG)
    else:
        root_logger.setLevel(logging.INFO)
        
    if profile:
        import statprof
        statprof.start()
        
    if iterable:
        for number, subobj in enumerate(iter(train_obj)):
            # Publish a variable indicating the training phase.
            phase_variable = 'PYLEARN2_TRAIN_PHASE'
            phase_value = 'phase%d' % (number + 1)
            os.environ[phase_variable] = phase_value

            # Execute this training phase.
            subobj.main_loop(time_budget=time_budget)

            # Clean up, in case there's a lot of memory used that's
            # necessary for the next phase.
            del subobj
            gc.collect()
    else:
        train_obj.main_loop(time_budget=time_budget)
    
    if profile:
        statprof.stop()
        with open('prof.out','w') as f:
            statprof.display(f)
        statprof.display()
        print 'note: profile results were also saved to prof.out'
Exemple #32
0
def filter_statprof(statprof):
    # only report the profiling for the Root node.. that's almost always what is needed.
    if mpi_info.is_I_root == False:
        return

    if platform.system().lower() != 'windows':
        if (statprof == None):
            PRINT(
                "Note: Profiling disabled. Unable to load the 'statprof' Python module. Install 'statprof'."
            )
            return
    else:
        PRINT(
            "Note: Profiling disabled when running under Windows because 'statprof' does not work."
        )
        return
    pass

    PRINT("Final Profiling Info")
    PRINT("-----------------------------------")

    PRINT("\t Include filters:")
    filtersInclude = None
    if filtersForFiltersInclude != None and len(filtersForFiltersInclude) > 0:
        filtersInclude = []
        for filter in filtersForFiltersInclude:
            PRINT("\t\t %s" % (str(filter), ))
            filtersInclude.append(str(filter))
    else:
        PRINT("\t\t None")

    PRINT("\t Exclude filters:")
    filtersExclude = None
    if filtersForFiltersExclude != None and len(filtersForFiltersExclude) > 0:
        filtersExclude = []
        for filter in filtersForFiltersExclude:
            PRINT("\t\t %s" % (str(filter), ))
            filtersExclude.append(str(filter))
    else:
        PRINT("\t\t None")

    PRINT("")
    PRINT("")

    outp = open('profile_data.txt', 'w')
    statprof.display(fp=outp)
    outp.close()

    inp = open('profile_data.txt', 'r')
    lines = inp.readlines()
    inp.close()

    error_lines = []
    profile_info = []
    line_number = -1

    for line in lines:
        line_number += 1
        # filter (include filter)
        if filtersInclude != None:
            found = False
            for name in filtersInclude:
                if line.find(name) > -1:
                    found = True
                    break
            if found == False:
                continue
        pass

        # filter (exclude filter)
        if filtersExclude != None:
            found = False
            for name in filtersExclude:
                if line.find(name) != -1:
                    found = True
            if found == True:
                continue
        pass

        if line_number > 1:
            try:
                numbers = re.findall(
                    r"([-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)", line)
                percent_time = float(numbers[0][0])
                cum_seconds = float(numbers[1][0])
                self_seconds = float(numbers[2][0])

                text = re.search(r"([a-zA-Z][\.\w\:]+)", line)
                info = text.group()
                #sort(key=lambda tup: tup[1])
                profile_info.append(
                    (percent_time, cum_seconds, self_seconds, info))
            except:
                error_lines.append(line)

    profile_info.sort(key=lambda sme: sme[0])

    for line in profile_info:
        PRINT("%f \t %f	\t %f \t %s" % (line[0], line[1], line[2], line[3]))
    if len(error_lines) > 0:
        PRINT("---------------------")
        PRINT("Error lines!")
        PRINT("")
        for line in error_lines:
            PRINT("\t %s" % line)
    PRINT("")
    PRINT(
        "Raw output in file 'profile_data.txt' and CSV data in 'profile.csv'")
    PRINT("")

    outp = open('profile_data.csv', 'w')
    for line in profile_info:
        outp.write("%f,%f,%f,%s\n" % (line[0], line[1], line[2], line[3]))
    outp.close()
Exemple #33
0
def generateOrders():  # pylint: disable=invalid-name
    """Called once per turn to tell the Python AI to generate and issue orders to control its empire.
    at end of this function, fo.doneTurn() should be called to indicate to the client that orders are finished
    and can be sent to the server for processing."""
    empire = fo.getEmpire()
    if empire.eliminated:
        print "This empire has been eliminated. Aborting order generation"
        try:
            # early abort if already eliminated. no need to do meter calculations
            # on last-seen gamestate if nothing can be ordered anyway...
            fo.doneTurn()
        except Exception as e:
            print_error(e)
        return

    # This code block is required for correct AI work.
    print "Meter / Resource Pool updating..."
    fo.initMeterEstimatesDiscrepancies()
    fo.updateMeterEstimates(0)
    fo.updateResourcePools()

    turn = fo.currentTurn()
    turn_uid = foAIstate.set_turn_uid()
    print "Start turn %s (%s) of game: %s" % (turn, turn_uid, foAIstate.uid)

    turn_timer.start("AI planning")
    # set the random seed (based on galaxy seed, empire name and current turn)
    # for game-reload consistency.
    random_seed = str(fo.getGalaxySetupData().seed) + "%05d%s" % (turn, fo.getEmpire().name)
    random.seed(random_seed)
    aggression_name = fo.aggression.values[foAIstate.aggression].name
    if turn == 1:
        declare_war_on_all()
        human_player = fo.empirePlayerID(1)
        fo.sendChatMessage(human_player,  '%s Empire (%s):\n"Ave, Human, morituri te salutant!"' % (empire.name, aggression_name))

    # turn cleanup !!! this was formerly done at start of every turn -- not sure why
    foAIstate.split_new_fleets()

    foAIstate.refresh()  # checks exploration border & clears roles/missions of missing fleets & updates fleet locs & threats
    foAIstate.report_system_threats()
    print("Calling AI Modules")
    # call AI modules
    action_list = [ColonisationAI.survey_universe,
                   ProductionAI.find_best_designs_this_turn,
                   PriorityAI.calculate_priorities,
                   ExplorationAI.assign_scouts_to_explore_systems,
                   ColonisationAI.assign_colony_fleets_to_colonise,
                   InvasionAI.assign_invasion_fleets_to_invade,
                   MilitaryAI.assign_military_fleets_to_systems,
                   FleetUtilsAI.generate_fleet_orders_for_fleet_missions,
                   FleetUtilsAI.issue_fleet_orders_for_fleet_missions,
                   ResearchAI.generate_research_orders,
                   ProductionAI.generateProductionOrders,
                   ResourcesAI.generate_resources_orders,
                   foAIstate.after_turn_cleanup,
                   ]

    for action in action_list:
        try:
            main_timer.start(action.__name__)
            action()
            main_timer.stop()
        except Exception as e:
            print_error(e, location=action.__name__)
    main_timer.end()
    turn_timer.end()
    turn_timer.start("Server_Processing")

    try:
        fo.doneTurn()
    except Exception as e:
        print_error(e)  # TODO move it to cycle above

    if using_statprof:
        try:
            statprof.stop()
            statprof.display()
            statprof.start()
        except:
            pass
def main():
    """ Test if an implementation CRN is a correct implementation of a formal CRN.

    An example from Robert's CRN bisimulation code:
    fCRN = "a -> b"
    icrn = "a1 -> b1; x -> a1; x -> b1; y -> b1; y -> a1; x -> a0; a0 -> a1"


    """
    parser = argparse.ArgumentParser(
        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
    add_commandline_arguments(parser)
    args = parser.parse_args()

    logger = logging.getLogger('crnverifier')
    logger.setLevel(logging.DEBUG)
    ch = logging.StreamHandler()
    formatter = logging.Formatter('%(levelname)s %(filename)s: %(message)s')
    ch.setFormatter(formatter)
    if args.verbose == 0:
        ch.setLevel(logging.WARNING)
    elif args.verbose == 1:
        ch.setLevel(logging.INFO)
    elif args.verbose == 2:
        ch.setLevel(logging.DEBUG)
    elif args.verbose >= 3:
        ch.setLevel(logging.NOTSET)
    logger.addHandler(ch)

    if args.profile:
        try:
            import statprof
            statprof.start()
        except ImportError as err:
            log.warning(
                'Cannot import statprof module. (pip install statprof-smarkets.)'
            )
            args.profile = False

    if args.method in ('crn-bisimulation', 'integrated-hybrid',
                       'compositional-hybrid'):
        # TODO: Interactive mode asks for input if fcrn isn't given, etc.
        assert args.formal_crn is not None
        assert args.implementation_crn is not None
        fcrn, icrn, fs, inter = get_bisimulation_inputs(
            args.formal_crn, args.implementation_crn, args.interpretation,
            args.constant_species)
        if args.method == 'crn-bisimulation':
            v = limit_runtime(args.verify_timeout,
                              crn_bisimulation_test,
                              fcrn,
                              icrn,
                              fs,
                              interpretation=inter,
                              permissive=args.permissive_check)
        elif args.method == 'compositional-hybrid':
            v = limit_runtime(args.verify_timeout, compositional_hybrid_test,
                              fcrn, icrn, fs, inter, not args.non_modular)

        else:
            assert args.method == 'integrated-hybrid'
            v = limit_runtime(args.verify_timeout, integrated_hybrid_test,
                              fcrn, icrn, fs, inter, not args.non_modular)

        # Unpack the verification results if it wasn't a timeout.
        (v, i) = (None, None) if v is None else v
        if v:
            log.info('Returned interpretation:\n  ' + \
                     '\n  '.join(f"{k} -> {' + '.join(v)}" for k, v in natural_sort(i.items())))
            log.info('Interpreted CRN:\n  {}'.format('\n  '.join(
                pretty_crn(clean_crn(icrn, inter=i)))))
        print_bisimulation_outputs(v, i, args.method, args.verify_timeout)

    elif args.method in ('modular-crn-bisimulation'):
        # TODO: Interactive mode asks for input if fcrn isn't given, etc.
        assert args.formal_crn is not None
        assert args.implementation_crn is not None
        fcrns, icrns, fs, inter = get_modular_bisimulation_inputs(
            args.formal_crn, args.implementation_crn, args.interpretation,
            args.constant_species)
        v = limit_runtime(args.verify_timeout,
                          modular_crn_bisimulation_test,
                          fcrns,
                          icrns,
                          fs,
                          interpretation=inter,
                          permissive=args.permissive_check)

        # Unpack the verification results if it wasn't a timeout.
        (v, i) = (None, None) if v is None else v
        if v:
            log.info("Returned interpretation:\n  " + \
                     '\n  '.join(f"{k} -> {' + '.join(v)}" for k, v in natural_sort(i.items())))
            for e, icrn in enumerate(icrns, 1):
                log.info('Interpreted CRN module {}:\n  {}'.format(
                    e, '\n  '.join(pretty_crn(clean_crn(icrn, inter=i)))))
        print_bisimulation_outputs(v, i, args.method, args.verify_timeout)

    elif args.method in ('formal-basis', 'pathway-decomposition'):
        # TODO: Interactive mode asks for input if fcrn isn't given, etc.
        if args.method == 'pathway-decomposition':
            assert len(args.crn_files) > 1
        assert len(args.formal_species)
        crns, fs = get_pathway_decomposition_inputs(args.crn_files,
                                                    args.formal_species,
                                                    args.constant_species)
        if args.method == 'pathway-decomposition':
            v = limit_runtime(args.verify_timeout, pathway_decomposition_eq,
                              crns, fs, not args.non_modular)
            if v is True:
                print(
                    f"Verification result for {args.method} = {v}. The CRNs are equivalent."
                )
            elif v is False:
                print(
                    f"Verification result for {args.method} = {v}. The CRNs are not equivalent."
                )
            elif v is None:
                print(
                    f"No verification result for {args.method}.",
                    f"Verification did not terminate within {args.verify_timeout} seconds."
                )
        elif args.method == 'formal-basis':
            for e, crn in enumerate(crns, 1):
                try:
                    v = limit_runtime(args.verify_timeout, get_formal_basis,
                                      crn, fs, not args.non_modular)

                    if v is None:
                        print('Timeout, no formal basis found.')
                    else:
                        fbasis, _ = v
                        print('Formal basis {}:\n  {}'.format(
                            e, "\n  ".join(pretty_crn(fbasis))))
                except NoFormalBasisError as err:
                    print("Could not find formal basis {}: {}".format(e, err))
    else:
        raise NotImplementedError(args.method)

    if args.profile:
        statprof.stop()
        statprof.display()
Exemple #35
0
def generateOrders():  # pylint: disable=invalid-name
    """Called once per turn to tell the Python AI to generate and issue orders to control its empire.
    at end of this function, fo.doneTurn() should be called to indicate to the client that orders are finished
    and can be sent to the server for processing."""
    turn = fo.currentTurn()
    turn_uid = foAIstate.set_turn_uid()
    print "Start turn %s (%s) of game: %s" % (turn, turn_uid, foAIstate.uid)

    turn_timer.start("AI planning")
    universe = fo.getUniverse()
    empire = fo.getEmpire()
    planet_id = PlanetUtilsAI.get_capital()
    # set the random seed (based on galaxy seed, empire ID and current turn)
    # for game-reload consistency 
    random_seed = str(fo.getGalaxySetupData().seed) + "%03d%05d" % (fo.empireID(), turn)
    random.seed(random_seed)
    planet = None
    if planet_id is not None:
        planet = universe.getPlanet(planet_id)
    aggression_name = fo.aggression.values[foAIstate.aggression].name
    print "***************************************************************************"
    print "**********   String for chart. Do not modify.   ***************************"
    print ("Generating Orders")
    print ("EmpireID: {empire.empireID}"
           " Name: {empire.name}_{empire.empireID}_pid:{p_id}_{p_name}RIdx_{res_idx}_{aggression}"
           " Turn: {turn}").format(empire=empire,  p_id=fo.playerID(), p_name=fo.playerName(),
                                   res_idx=ResearchAI.get_research_index(), turn=turn,
                                   aggression=aggression_name.capitalize())
    print "EmpireColors: {0.colour.r} {0.colour.g} {0.colour.b} {0.colour.a}".format(empire)
    if planet:
        print "CapitalID: " + str(planet_id) + " Name: " + planet.name + " Species: " + planet.speciesName
    else:
        print "CapitalID: None Currently Name: None Species: None "
    print "***************************************************************************"
    print "***************************************************************************"

    if turn == 1:
        declare_war_on_all()
        human_player = fo.empirePlayerID(1)
        fo.sendChatMessage(human_player,  '%s Empire (%s):\n"Ave, Human, morituri te salutant!"' % (empire.name, aggression_name))

    # turn cleanup !!! this was formerly done at start of every turn -- not sure why
    foAIstate.split_new_fleets()

    foAIstate.refresh()  # checks exploration border & clears roles/missions of missing fleets & updates fleet locs & threats
    foAIstate.report_system_threats()
    # ...missions
    # ...demands/priorities
    print("Calling AI Modules")
    # call AI modules
    action_list = [ColonisationAI.survey_universe,
                   ProductionAI.find_best_designs_this_turn,
                   PriorityAI.calculate_priorities,
                   ExplorationAI.assign_scouts_to_explore_systems,
                   ColonisationAI.assign_colony_fleets_to_colonise,
                   InvasionAI.assign_invasion_fleets_to_invade,
                   MilitaryAI.assign_military_fleets_to_systems,
                   FleetUtilsAI.generate_fleet_orders_for_fleet_missions,
                   FleetUtilsAI.issue_fleet_orders_for_fleet_missions,
                   ResearchAI.generate_research_orders,
                   ProductionAI.generateProductionOrders,
                   ResourcesAI.generate_resources_orders,
                   foAIstate.after_turn_cleanup,
                   ]

    for action in action_list:
        try:
            main_timer.start(action.__name__)
            action()
            main_timer.stop()
        except Exception as e:
            print_error(e, location=action.__name__)
    main_timer.end()
    turn_timer.end()
    turn_timer.start("Server_Processing")

    try:
        fo.doneTurn()
    except Exception as e:
        print_error(e)  # TODO move it to cycle above

    if using_statprof:
        try:
            statprof.stop()
            statprof.display()
            statprof.start()
        except:
            pass
Exemple #36
0
def get_output(**kwargs):
    buffer = StringIO()
    display(buffer, **kwargs)
    buffer.seek(0)
    return buffer.read()