#!/usr/bin/python
from status import Status
print("Demo of enums in python")
print("")
print("Step 1: creating a variable of type Status with value OPEN")
status = Status.OPEN
print("Status: " + str(status))
print("Step 2: Setting the status with a numeric value")
another_status = Status(2)
print(another_status)
print("Step 2: checking the value of the enum variable...")
if status == Status.COMPLETED:
print("Congrats, the task is completed")
else:
print("Sorry, the task is not completed yet")
print("Step 3: See all available values for the enumeration status...")
for status in Status:
print(status)
print("Step 4: accessing the enum by numeric value: Status(1)")
print(Status(1))
print(
"Step 5: accessing an enum value that does not exist: Status(4) should not exist"
)
try:
print(Status(4))
"""
This module provides the Plugin class, which is the basic
class which encapsulates a single plugin. This is the class
which should be subclassed when creating new plugins.
"""
import sys
from copy import copy
from optparse import Option, OptionParser, make_option
from range import Range, RangeValueError
from response import Response
from status import Status
# Status constants which contain both the status text and the
# exit status associated with them.
OK = Status("OK", 0)
WARNING = Status("WARN", 1)
CRITICAL = Status("CRIT", 2)
UNKNOWN = Status("UNKNOWN", 3)
def check_pynagios_range(option, opt, value):
"""
This parses and returns the Nagios range value.
"""
try:
return Range(value)
except RangeValueError, e:
raise OptionValueError("options %s: %s" % (opt, e.message))
def run_game():
pygame.init()
Kulami_settings = Settings()
background = pygame.image.load(Kulami_settings.initial_background)
pygame.display.set_caption("Kulami")
while True:
screen = pygame.display.set_mode(
(background.get_width(), background.get_height()))
screen.blit(background, (0, 0))
startbutton = StartButton(screen)
startbutton.blitme()
addbutton = AddButton(screen, startbutton)
addbutton.blitme()
reducebutton = ReduceButton(screen, startbutton)
reducebutton.blitme()
inputfield = InputFiled(screen, addbutton, reducebutton)
inputfield.blitme()
stats = Stats()
font = pygame.font.Font(Kulami_settings.font, 40)
surface = font.render(str(stats.width), True,
Kulami_settings.font_color)
screen_rect = screen.get_rect()
screen.blit(
surface,
(int(screen_rect.centerx - 0.5 * surface.get_width()),
int(reducebutton.rect.centery - 0.5 * surface.get_height())))
while True:
gf.check_events(stats, startbutton, addbutton, reducebutton)
# marble.blitme_xy(0,0)
inputfield.blitme()
surface = font.render(str(stats.width), True, (154, 202, 64))
screen.blit(
surface,
(int(screen_rect.centerx - 0.5 * surface.get_width()),
int(reducebutton.rect.centery - 0.5 * surface.get_height())))
pygame.display.flip()
if stats.game_active:
break
screen = pygame.display.set_mode(
(stats.width * Kulami_settings.hole_size,
stats.height * Kulami_settings.hole_size))
board = Board(screen, stats.width, stats.height,
Kulami_settings.bg_color, Kulami_settings.hole_size,
Kulami_settings.tile_edge_color)
board.blitme()
pygame.display.flip()
gameStatus = Status(stats.width, stats.height)
board.init_board_feature()
cnnModel = CNNModel(
Kulami_settings.trainset_address + "_size_" + str(board.width) +
".txt", gameStatus, board, Kulami_settings.robot_turn)
cnnModel.train()
robot = Robot(gameStatus, board, screen, Kulami_settings.hole_size,
"Minmax", Kulami_settings.robot_turn,
Kulami_settings.robot_IQ, cnnModel)
while True:
if gameStatus.turn == Kulami_settings.robot_turn:
robot.play()
continue
g = bf.check_events(gameStatus, screen, Kulami_settings.hole_size,
board)
pygame.display.flip()
if gameStatus.end:
print("Game over")
print("red score:", gameStatus.red_score, "black score:",
gameStatus.black_score)
if gameStatus.red_score > gameStatus.black_score:
print("RED WIN!")
gameStatus.result = 0
elif gameStatus.black_score > gameStatus.red_score:
print("BLACK WIN!")
gameStatus.result = 1
else:
print("TIE!")
gameStatus.result = 2
break
result = Result(screen, Kulami_settings.bg_color, gameStatus,
Kulami_settings)
result.blitme()
restartbutton = RestartButton(screen)
restartbutton.blitme()
pygame.display.flip()
while True:
g = rf.check_events(stats, restartbutton)
if stats.game_restart:
stats.game_restart = False
break
async def receive_sync(self, request):
'''
Update the checkpoint and fill the bubble when receive sync messages.
input:
request: {
'checkpoint': json_data = {
'next_slot': self._next_slot
'ckpt': json.dumps(ckpt)
}
'commit_certificates':commit_certificates
(Elements are commit_certificate.to_dict())
}
'''
self._log.info("%d: on receive sync stage.", self._index)
json_data = await request.json()
try:
# print(len(self._status_by_slot))
# print(self._ckpt.next_slot, self._last_commit_slot + 1)
# # print(len(json_data['checkpoint']))
# print('node :' + str(self._index) +' > '+str(self._blockchain.commit_counter)+' : '+str(self._blockchain.length))
# print()
# print()
self.committed_to_blockchain = False
except Exception as e:
traceback.print_exc()
print('for i = ' + str(i))
print(e)
self._ckpt.update_checkpoint(json_data['checkpoint'])
self._last_commit_slot = max(self._last_commit_slot,
self._ckpt.next_slot - 1)
# TODO: Only check bubble instead of all slots between lowerbound
# and upperbound of the commit.
for slot in json_data['commit_certificates']:
# Skip those slot not qualified for update.
if int(slot) >= self._ckpt.get_commit_upperbound() or (
int(slot) < self._ckpt.next_slot):
continue
certificate = json_data['commit_certificates'][slot]
if slot not in self._status_by_slot:
self._status_by_slot[slot] = Status(self._f)
commit_certificate = Status.Certificate(View(
0, self._node_cnt))
commit_certificate.dumps_from_dict(certificate)
self._status_by_slot[
slot].commit_certificate = commit_certificate
elif not self._status_by_slot[slot].commit_certificate:
commit_certificate = Status.Certificate(View(
0, self._node_cnt))
commit_certificate.dumps_from_dict(certificate)
self._status_by_slot[
slot].commit_certificate = commit_certificate
# Commit once the next slot of the last_commit_slot get commit certificate
while (str(self._last_commit_slot + 1) in self._status_by_slot
and self._status_by_slot[str(self._last_commit_slot +
1)].commit_certificate):
self._last_commit_slot += 1
# When commit messages fill the next checkpoint,
# propose a new checkpoint.
if (self._last_commit_slot + 1) % self._checkpoint_interval == 0:
await self._ckpt.propose_vote(self.get_commit_decisions())
self._log.info(
"%d: During rev_sync, Propose checkpoint with l "
"ast slot: %d. In addition, current checkpoint's next_slot is: %d",
self._index, self._last_commit_slot, self._ckpt.next_slot)
await self.dump_to_file()
return web.Response()
def main__1st_run_from_commandline(args=None, debug_in=None):
args = process_args(args=args)
# Either read input files, or use the debug_in which should contain config/status in array of strings
status_file = None
if debug_in:
config_file = "__debug__"
cfg_arr = debug_in["config"]
sts_arr = debug_in["status"]
else:
config_file = ".relay-cfg"
if args.config_file:
config_file = args.config_file
status_file = ".relay-sts"
if args.status_file:
status_file = args.status_file
cfg_arr, sts_arr = read_input_files(config_file, status_file)
# Process the input information
control = Control()
config, status = parse_input_info(cfg_arr, sts_arr, control)
if config:
config.filename = config_file
else:
print("Parse issue with Config file {} please check and try again".
format(config_file))
return relay_exit_codes.EXIT_CODE_ERROR_WITH_CONFIG_FILE, None
validation_res, text = config.validate()
app_exit_code = display_validation(validation_res, text, config_file)
if app_exit_code != relay_exit_codes.EXIT_CODE_OK:
return app_exit_code, None
if status:
status.filename = status_file
else:
print("Proceeding with no status file (will create at end)")
# create status structure for each socket
status = Status(status_file)
# process the override comandline options
new_overrides = process_arg_overrides(args)
# Parse commandline options for validity
validation_res, text = validate_args(new_overrides, config)
if validation_res == relay_exit_codes.EXIT_CODE_CMDLINE_ERROR_UNRECOGNISED_SOCKET:
print("Unrecognised socket {} in commandline".format(text))
return validation_res, None
# now take the info read from the config and status files and process the info
set_location_coords(config.app.coords)
ret_code = relay_process(control, config, status, new_overrides)
if ret_code:
return ret_code, None
# re-write the status file
status.write_file()
# if status_file:
# #dir_path = os.path.dirname(os.path.realpath(__file__))
# full_path = status_file
# #full_path = dir_path + '/' + status_file
# status.write_file (full_path)
# configure & start thread to monitor board inputs, only do this
# if the front panel is present
if config.app.front_panel_present:
thread = threading.Thread(target=update_board_inputs,
args=(control, config, status))
thread.start()
# Now see if we want to run the app continously
if config.app:
if config.app.update_timer != App.APP_SINGLE_RUN_TIMER:
# Now see if we want to run up the web server and or the socket
if config.app.socket_active:
# Start the socket used for controlling the app
pass
if config.app.webserver_active:
# Start the webserver used for controlling the app
#thread = threading.Thread(target=websrv_01.run, kwargs={'port': config.app.webserver_port,'debug': True})
webserver_set_config_status(control, config, status,
relay_process)
thread = threading.Thread(target=web_svr.run,
kwargs={
'host': '0.0.0.0',
'port': config.app.webserver_port
})
thread.start()
pass
# schedule a timer to kick the logic processing
update_time = config.app.update_timer
if args.super_time:
update_time = config.app.update_timer / args.super_time
control.schedule_run(update_time)
# configure & start thread
thread = threading.Thread(target=main__run_from_scheduler,
args=(control, config, status))
thread.start()
if args.super_time:
st_args = [control, args.super_time]
st_thread = threading.Thread(target=supertime_change_time,
args=st_args)
st_thread.start()
# #For debugging the image drawing
# # Prep the filename of the image generated
# multi_day = "/home/marc/temp/mja02.png"
#
# # generate the image
# start_date = time_now() - timedelta(days = 100)
# end_date = time_now() + timedelta(days = 100)
# from print_utils import print_days_image
# print_days_image(multi_day, start_date, end_date, config, "SnugLHS", day_height=2, strobe=7)
return relay_exit_codes.EXIT_CODE_OK, control
def say(self, message):
statement = "%s said: %s" % (self, message)
if self.statusQueue:
self.statusQueue.put(Status(self.name, message))
else:
print(statement)
def __init__(self, master, camera, uart):
"""Create a main application with the root thread, camera, and
UART instances."""
# Member Data
#######################################################
self.tracker = CentroidTracker()
self.controller = Controller()
self.test = "alnilam"
self.status = Status()
self.threshold = 5
self.camera = camera
self.UART = uart
# GUI Status Data
#######################################################
self.exposing = False
self.calibrating = False
self.calibrated = False
self.running = False
# Calibration Data
#######################################################
self.calibration = Calibration()
# Primary GUI Objects
#######################################################
# master root frame
self.master = master
# self.img - cv2 binary image without any markup
# self.gui_img - PIL colored image with markup
self.img, self.gui_img = initial_img_load(self.tracker)
# Holds image frame
self.panel = Label(master, image=self.gui_img)
self.panel.pack(side=LEFT)
# Contains all control and output widgets right of image panel
self.frame = Frame(master)
self.frame.pack(side=RIGHT, expand=TRUE, fill=BOTH)
# data that contains calibration and guiding status data
self.status_txt = StringVar()
self.status_txt.set(self.tracker.status)
# GUI object containing status data
self.text = Label(self.frame, textvariable=self.status_txt)
self.text.config(height=10,
width=32,
justify="left",
bg="grey25",
fg="white")
self.text.pack()
# Secondary GUI Objects (widgets)
#######################################################
# load Astrothoughts Logo
self.logo_img = load_logo()
self.logo = Label(self.frame, image=self.logo_img)
self.logo.pack(side=BOTTOM, anchor=S)
# Binary threshold slider
self.slider = Scale(self.frame,
from_=0,
to=200,
orient=HORIZONTAL,
length=225)
self.slider.config(sliderlength=15,
label="Binary Threshold",
bg="grey25",
fg="white")
self.slider.set(5)
self.slider.pack()
# Loop button
self.expose_img = PhotoImage(file="figures/expose.png")
self.expose_btn = Button(self.frame,
image=self.expose_img,
command=self.expose_button_cb)
self.expose_btn.config(height=51, width=51, bg="white")
self.expose_btn.pack(side="left", anchor=NW)
self.expose_ttp = CreateToolTip(
self.expose_btn, "Begin looping exposures from tracking camera")
# Run button
self.run_img = PhotoImage(file="figures/run_gs.png")
self.run_btn = Button(self.frame,
image=self.run_img,
command=self.run_button_cb)
self.run_btn.config(height=51, width=51, bg="white")
self.run_btn.pack(side="left", anchor=NW)
self.run_ttp = CreateToolTip(self.run_btn, "Start autoguiding program")
# Stop button
self.stop_img = PhotoImage(file="figures/stop_gs.png")
self.stop_btn = Button(self.frame,
image=self.stop_img,
command=self.stop_button_cb)
self.stop_btn.config(height=51, width=51, bg="white")
self.stop_btn.pack(side="left", anchor=NW)
self.stop_ttp = CreateToolTip(self.stop_btn,
"Stop looping and guiding")
# Calibration button
self.cal_img = PhotoImage(file="figures/cal_gs.png")
self.cal_btn = Button(self.frame,
image=self.cal_img,
command=self.cal_button_cb)
self.cal_btn.config(height=51, width=51, bg="white")
self.cal_btn.pack(side="left", anchor=NW)
self.cal_ttp = CreateToolTip(self.cal_btn,
"Begin calibration sequence")
def test_str(self):
# Testing __str__
s = Status(Status.INIT)
s = Status.WAIT
assert str(s) == 'W', 'should be W'
def __init__(self):
"""
This method is constructor.
"""
System()
Gtk.Window.__init__(self, title="Mosaicode")
# self.set_default_size(800,600)
self.resize(
System.properties.width,
System.properties.height)
self.main_control = MainControl(self)
self.connect("check-resize", self.__resize)
# GUI components
self.menu = Menu(self)
self.toolbar = Toolbar(self)
self.search = SearchBar(self)
self.block_notebook = BlockNotebook(self)
self.block_properties = BlockProperties(self)
self.work_area = WorkArea(self)
self.status = Status(self)
System.set_log(self.status)
# vbox main
# -----------------------------------------------------
# | Menu
# -----------------------------------------------------
# | Toolbar
# -----------------------------------------------------
# | V Paned bottom
# -----------------------------------------------------
# First Vertical Box
vbox_main = Gtk.VBox()
self.add(vbox_main)
vbox_main.pack_start(self.menu, False, True, 0)
vbox_main.pack_start(self.toolbar, False, False, 0)
self.vpaned_bottom = Gtk.Paned.new(Gtk.Orientation.VERTICAL)
vbox_main.add(self.vpaned_bottom)
# vpaned_bottom
# -----------------------------------------------------
# | hpaned_work_area
# =====================================================
# | status
# -----------------------------------------------------
self.hpaned_work_area = Gtk.HPaned()
self.hpaned_work_area.connect("accept-position", self.__resize)
self.hpaned_work_area.set_position(System.properties.hpaned_work_area)
self.vpaned_bottom.add1(self.hpaned_work_area)
self.vpaned_bottom.add2(self.__create_frame(self.status))
self.vpaned_bottom.set_position(System.properties.vpaned_bottom)
self.vpaned_bottom.set_size_request(50, 50)
# hpaned_work_area
# -----------------------------------------------------
# | vbox_left || work_area
# -----------------------------------------------------
vbox_left = Gtk.VBox(False, 0)
self.hpaned_work_area.add1(vbox_left)
self.hpaned_work_area.add2(self.work_area)
# vbox_left
# -----------------------------------------------------
# |search
# -----------------------------------------------------
# |vpaned_left
# -----------------------------------------------------
vbox_left.pack_start(self.search, False, False, 0)
self.vpaned_left = Gtk.VPaned()
vbox_left.pack_start(self.vpaned_left, True, True, 0)
# vpaned_left
# -----------------------------------------------------
# |blocks_tree_view
# =====================================================
# | block_properties
# -----------------------------------------------------
self.vpaned_left.add1(self.__create_frame(self.block_notebook))
self.vpaned_left.add2(self.__create_frame(self.block_properties))
self.vpaned_left.set_position(System.properties.vpaned_left)
self.connect("delete-event", self.main_control.exit)
self.connect("key-press-event", self.__on_key_press)
for example in System.list_of_examples:
self.menu.add_example(example)
self.menu.update_recent_file()
def __valid_username(self, username: str):
if username not in self.users:
return Status(499, "User not found")
return Status(200, "success")
'''Stater of game''' from colorama import init from status import Status init() STATUS = Status() STATUS.make_game()
def __init__(self):
s2idirectory.load()
Gtk.Window.__init__(self, title="Harpia")
#self.set_default_size(800,600)
self.set_property("height_request", 500)
self.maximize()
self.set_size_request(900, 500) #Controla o tamanho minimo
self.main_control = MainControl(self)
self.connect("check-resize", self.__resize)
#GUI components
self.menu = Menu(self)
self.toolbar = Toolbar(self)
self.search = SearchBar(self)
self.blocks_tree_view = BlocksTreeView(self)
self.block_properties = BlockProperties(self)
self.work_area = WorkArea(self)
self.status = Status(self)
s2idirectory.Log = self.status
# vbox main
# -----------------------------------------------------
# | Menu
# -----------------------------------------------------
# | Toolbar
# -----------------------------------------------------
# | V Paned bottom
# -----------------------------------------------------
# First Vertical Box
vbox_main = Gtk.VBox()
self.add(vbox_main)
vbox_main.pack_start(self.menu, False, True, 0)
vbox_main.pack_start(self.toolbar, False, False, 0)
self.vpaned_bottom = Gtk.Paned.new(Gtk.Orientation.VERTICAL)
vbox_main.add(self.vpaned_bottom)
# vpaned_bottom
# -----------------------------------------------------
# | hpaned_work_area
# =====================================================
# | status
# -----------------------------------------------------
hpaned_work_area = Gtk.HPaned()
self.vpaned_bottom.add1(hpaned_work_area)
self.vpaned_bottom.add2(self.__create_frame(self.status))
self.vpaned_bottom.set_position(420)
self.vpaned_bottom.set_size_request(50, 50)
# hpaned_work_area
# -----------------------------------------------------
# | vbox_left || work_area
# -----------------------------------------------------
vbox_left = Gtk.VBox(False, 0)
hpaned_work_area.add1(vbox_left)
hpaned_work_area.add2(self.work_area)
# vbox_left
# -----------------------------------------------------
# |search
# -----------------------------------------------------
# |vpaned_left
# -----------------------------------------------------
vbox_left.pack_start(self.search, False, False, 0)
self.vpaned_left = Gtk.VPaned()
vbox_left.pack_start(self.vpaned_left, True, True, 0)
# vpaned_left
# -----------------------------------------------------
# |blocks_tree_view
# =====================================================
# | block_properties
# -----------------------------------------------------
self.vpaned_left.add1(self.__create_frame(self.blocks_tree_view))
self.vpaned_left.add2(self.__create_frame(self.block_properties))
self.vpaned_left.set_position(300)
#self.vpaned_left.set_size_request(50,50)
#self.vpaned_left.set_property("min-position",150)
self.connect("delete-event", self.quit)
# Load Examples
list_of_examples = glob(os.environ['HARPIA_DATA_DIR'] + "examples/*")
list_of_examples.sort()
for example in list_of_examples:
self.menu.add_example(example)
self.menu.add_recent_file("/home/flavio/Desktop/harpiaTest.hrp")
self.menu.add_recent_file("/home/flavio/Desktop/harpiaTest2.hrp")
from status import Status
etat = Status("http://pf4.ddns.net/api/etat_bots.json")
print(etat.get_status("fire dragon#8794"))
def __init__(self, title=None, status=None):
self.title = title if title else ""
self.status = status if status else Status()
def main():
try:
parser = argparse.ArgumentParser(description='Parser')
parser.add_argument('--rowfile', help='row file')
parser.add_argument('--colfile', help='column file', default=None)
parser.add_argument('--outfile', help='output file')
parser.add_argument('--pearson',
dest='spearman',
help='use pearson correlation',
action='store_false')
parser.add_argument('--pvalue',
help='p-value threshold',
type=float,
default=None)
parser.add_argument('--rho',
help='correlation (rho) threshold',
type=float,
default=None)
parser.add_argument('--loglevel', help='set log level', default='info')
parser.add_argument('--logfile', help='set log file', default=None)
args = parser.parse_args()
level = args.loglevel.upper()
try:
level = getattr(log, level)
except AttributeError:
level = log.INFO
if args.logfile is not None:
try:
os.makedirs(os.path.dirname(args.logfile))
except OSError:
pass
log.getLogger().handlers = []
log.basicConfig(
level=level,
filename=args.logfile,
format='%(asctime)s.%(msecs)d %(levelname)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
log.info('row file is %s', args.rowfile)
log.info('column file is %s', args.colfile)
log.info('output file is %s', args.outfile)
log.info('spearman is %s', args.spearman)
log.info('p-value threshold is %s', args.pvalue)
log.info('rho threshold is %s', args.rho)
log.info('log level is %s (%d)', args.loglevel, level)
log.info('log file is %s', args.logfile)
status = Status(name='correlator').start()
correlate(args.outfile,
args.rowfile,
args.colfile,
spearman=args.spearman,
pvalue_threshold=args.pvalue,
rho_threshold=args.rho)
status.stop()
return 0
except KeyboardInterrupt:
return 1
except Exception, e:
sys.stderr.write(repr(e) + '\n')
sys.stderr.write('for help use --help\n')
return 2
def __init__(self):
self.status = Status()
self.choices = {"1": self.show_ip, "2": self.show_page, "3": self.quit}
def correlate(outfile,
row_filename,
col_filename=None,
spearman=True,
pvalue_threshold=None,
rho_threshold=None):
row_row_names, row_col_names, row_data = parse(row_filename)
if col_filename is None:
col_filename = row_filename
symmetric = row_filename == col_filename
if not symmetric:
col_row_names, col_col_names, col_data = parse(col_filename)
col_names = set(row_col_names).intersection(col_col_names)
row_data = align(col_names, row_col_names, row_data)
col_data = align(col_names, col_col_names, col_data)
col_row_names, col_data = prune(col_row_names, col_data)
ncols = len(col_row_names)
row_row_names, row_data = prune(row_row_names, row_data)
nrows = len(row_row_names)
if symmetric:
col_row_names, col_data, ncols = row_row_names, row_data, nrows
if nrows == 0 or ncols == 0:
return
if spearman:
status = Status('ranking for spearman correlation').start()
row_data = np.array([rankdata(r) for r in row_data])
col_data = row_data if symmetric else np.array(
[rankdata(c) for c in col_data])
status.stop()
if symmetric:
def complete(r):
return r * (r - 1) / 2 + r * (nrows - r)
else:
def complete(r):
return r * ncols
status = Status('writing ' + outfile).n(
complete(nrows)).units('correlations').start()
try:
os.makedirs(os.path.dirname(outfile))
except:
pass
with open(outfile, 'wt') as fid:
for r in xrange(nrows):
for c in xrange(r + 1 if symmetric else 0, ncols):
(rho, pvalue) = pearsonr(row_data[r], col_data[c])
if (rho_threshold is None or math.fabs(rho) > rho_threshold
) and (pvalue_threshold is None
or pvalue < pvalue_threshold):
fid.write(
'%s\t%s\t%0.3e\t%0.3e\n' %
(row_row_names[r], col_row_names[c], rho, pvalue))
status.log(complete(r))
status.stop()
def __init__(self, status = Status(), header = Header(), body = ''): #Body()):
self.status = status
self.header = header
self.body = body
def __init__(self, clientName, password='', run=True, **jsonConfigKeysToOverride):
self.clientName = clientName
self.password = password
self.isrunning = run
self.localTimestamp = time()
self.localDateTime = datetime.fromtimestamp(self.localTimestamp)
logMessage = f'\n\n{self.localDateTime}\nSession created with "{self.clientName}" credentials and run = {run}'
log.event_log_append(logMessage)
log.raw_log_append(logMessage)
"""
with open(paths.clientConfig, 'r') as f:
jsonClientConfig = json.load(f)
self.clientData = jsonClientConfig[client_name]
"""
with open(paths.sessionConfig, 'r') as f:
jsonSessionConfig = json.load(f)
for key in jsonConfigKeysToOverride:
jsonSessionConfig[key] = jsonConfigKeysToOverride[key]
self.marketsBuffer = jsonSessionConfig["sessionData"]["marketsBuffer"]
markets_buffer_format_check(self.marketsBuffer)
self.marketsBuffer = remove_inactive_markets_from_buffer(self.marketsBuffer)
self.marketsBuffer = marketsBufferAmountsSplitting(self.marketsBuffer)
# RESTRICTIONS TO BE IMPLEMENTE IN STATUS, NOT HERE!!!!!!
# statuses = [] # [ID, runningOrClosed, crashingInfo, *args]
wait = DEFAULT_WAIT
if self.isrunning:
self.sessionID = ID("session")
logMessage = f'Session has started with session ID: {self.sessionID.partialID}.\n'
log.event_log_append(logMessage)
log.raw_log_append(logMessage)
while self.isrunning:
log.event_log_append('\nCurrent marketsBuffer = ', self.marketsBuffer)
try:
newStatus = Status(self.clientName, self.password, self.marketsBuffer[0])
wait = DEFAULT_WAIT
except IDOverflowError:
self.statusIDReset = ID("status", getNew=False, reset=True)
self.isrunning = False
logMessage = f'\nSession terminated for statusID overflow.\n'
log.event_log_append(logMessage)
log.raw_log_append(logMessage)
break
except Exception as err:
if wait < MAX_WAIT:
wait *= WAIT_MULTIPLIER_0
logMessage = f'\nStatus crashed with error:\n {err.__repr__()}\n'
log.event_log_append(logMessage)
log.raw_log_append(logMessage)
log.error_log_append(err.__repr__(), self.sessionID.partialID, ID("status", getNew=False, reset=False).partialID)
#if newStatus.getMarketData() is different from marketData, update sessionConfig.json
try: self.lastMarket = newStatus.getMarketData()
except: self.lastMarket = self.marketsBuffer[0]
if len(self.marketsBuffer) > 1:
self.marketsBuffer = self.marketsBuffer[1:]
self.marketsBuffer.append(self.lastMarket)
sleep(wait)
def __init__(self):
"""
This method is constructor.
"""
System()
Gtk.Window.__init__(self, title="Mosaicode")
self.resize(System.get_preferences().width,
System.get_preferences().height)
self.main_control = MainControl(self)
# GUI components
self.menu = Menu(self)
self.toolbar = Toolbar(self)
self.search = SearchBar(self)
self.block_notebook = BlockNotebook(self)
self.property_box = PropertyBox(self)
self.work_area = WorkArea(self)
self.status = Status(self)
self.diagram_menu = DiagramMenu()
self.menu.add_help()
System.set_log(self.status)
# vbox main
# -----------------------------------------------------
# | Menu
# -----------------------------------------------------
# | Toolbar
# -----------------------------------------------------
# | V Paned bottom
# -----------------------------------------------------
# First Vertical Box
vbox_main = Gtk.VBox()
self.add(vbox_main)
vbox_main.pack_start(self.menu, False, True, 0)
vbox_main.pack_start(self.toolbar, False, False, 0)
self.vpaned_bottom = Gtk.Paned.new(Gtk.Orientation.VERTICAL)
vbox_main.add(self.vpaned_bottom)
# vpaned_bottom
# -----------------------------------------------------
# | hpaned_work_area
# =====================================================
# | status
# -----------------------------------------------------
self.hpaned_work_area = Gtk.HPaned()
self.hpaned_work_area.connect("accept-position", self.__resize)
self.hpaned_work_area.set_position(
System.get_preferences().hpaned_work_area)
self.vpaned_bottom.add1(self.hpaned_work_area)
self.vpaned_bottom.add2(self.__create_frame(self.status))
self.vpaned_bottom.set_position(System.get_preferences().vpaned_bottom)
self.vpaned_bottom.set_size_request(50, 50)
# hpaned_work_area
# -----------------------------------------------------
# | vbox_left || work_area
# -----------------------------------------------------
vbox_left = Gtk.VBox(False, 0)
self.hpaned_work_area.add1(vbox_left)
self.hpaned_work_area.add2(self.work_area)
# vbox_left
# -----------------------------------------------------
# |search
# -----------------------------------------------------
# |vpaned_left
# -----------------------------------------------------
vbox_left.pack_start(self.search, False, False, 0)
self.vpaned_left = Gtk.VPaned()
vbox_left.pack_start(self.vpaned_left, True, True, 0)
# vpaned_left
# -----------------------------------------------------
# |blocks_tree_view
# =====================================================
# |property_box
# -----------------------------------------------------
self.vpaned_left.add1(self.__create_frame(self.block_notebook))
self.vpaned_left.add2(self.__create_frame(self.property_box))
self.vpaned_left.set_position(System.get_preferences().vpaned_left)
self.connect("key-press-event", self.__on_key_press)
self.connect("check-resize", self.__resize)
self.main_control.init()
async def reply(self, request):
'''
Once receive more than 2f + 1 commit message, append the commit
certificate and cannot change anymore. In addition, if there is
no bubbles ahead, commit the given slots and update the last_commit_slot.
input:
request: commit message from commit:
preprepare_msg = {
'index': self._index,
'n': self._n,
'proposal': {
this_slot: json_data
}
'type': 'commit'
}
'''
json_data = await request.json()
# self._log.info(" %d: on reply", self._index)
# print("\t--->node "+str(self._index)+": on reply ")
if json_data['view'] < self._follow_view.get_view():
# when receive message with view < follow_view, do nothing
return web.Response()
self._log.info(" %d: receive commit msg from %d", self._index,
json_data['index'])
for slot in json_data['proposal']:
if not self._legal_slot(slot):
self._log.error("%d: message %s not in valid slot",
self._index, json_data)
continue
if slot not in self._status_by_slot:
self._status_by_slot[slot] = Status(self._f)
status = self._status_by_slot[slot]
view = View(json_data['view'], self._node_cnt)
status._update_sequence(json_data['type'], view,
json_data['proposal'][slot],
json_data['index'])
# Commit only when no commit certificate and got more than 2f + 1
if not status.commit_certificate and status._check_majority(
json_data['type']):
status.commit_certificate = Status.Certificate(
view, json_data['proposal'][slot])
self._log.debug("Add commit certifiacte to slot %d", int(slot))
# Reply only once and only when no bubble ahead
if self._last_commit_slot == int(
slot) - 1 and not status.is_committed:
status.is_committed = True
self._last_commit_slot += 1
if not self._is_leader:
self._next_propose_slot += 1
# When commit messages fill the next checkpoint, propose a new checkpoint.
if (self._last_commit_slot +
1) % self._checkpoint_interval == 0:
self._log.info(
"%d: Propose checkpoint with last slot: %d. "
"In addition, current checkpoint's next_slot is: %d",
self._index, self._last_commit_slot,
self._ckpt.next_slot)
await self._ckpt.propose_vote(
self.get_commit_decisions())
if (self._last_commit_slot + 1) % self._dump_interval == 0:
await self.dump_to_file()
reply_msg = {
'index': self._index,
'view': json_data['view'],
'proposal': json_data['proposal'][slot],
'type': MessageType.REPLY
}
try:
await self._session.post(
json_data['proposal'][slot]['client_url'],
json=reply_msg)
except:
self._log.error(
"Send message failed to %s",
json_data['proposal'][slot]['client_url'])
pass
else:
self._log.info(
"%d reply to %s successfully!!", self._index,
json_data['proposal'][slot]['client_url'])
return web.Response()
def update(self):
z = self.vehicle.z
self.vehicle.front_estimated_status = Status(*z[:3])
self.vehicle.estimated_status = Status(*z[3:6])
self.vehicle.front_estimated_diff = Status(*z[6:9])
import json
with open("config.json") as file:
json_data = json.load(file)
def job():
status.get_groups_handler()
status.format_link()
status.run()
send.send_string(status.display_result())
status = Status(json_data["url"], json_data["groups"]["groups_num"])
status.get_groups_handler()
status.format_link()
status.run()
status.display_result()
send = Send(json_data["serial"]["interface"], json_data["serial"]["baud_rate"])
schedule.every(1).seconds.do(job)
while 1:
schedule.run_pending()
time.sleep(1)
send.close()
#!/usr/bin/env python2.6
import datetime, json, sys, time, web
from threading import Thread
from status import Status
## "local" imports
import checks
## we'll factor this stuff out later
urls = ("/status.(json|xml)", "status", "/status", "status", "/checkin(.*)",
"checkin", "/healthcheck", "healthcheck", "/(.*)", "default")
app = web.application(urls, globals())
global_status = Status()
class checkin:
## currently we only support HTTP and TCP health checks,
## and we always pass web.input().get("path") to the healthcheck.
## there's probably a better way to do this.
HEALTH_CHECKS = {
"tcp": checks.TcpHealthCheck,
"http": checks.HttpHealthCheck
}
def GET(self, *args):
data = web.input(host=None, port=None, healthCheck=None)
if data.host is None or data.port is None:
return json.dumps({
def main():
import argparse
parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--save_dir', type = str, help='where is the model saved', default="GPO5/mix20_120")
parser.add_argument('--best_model', type = int, help="the index of the best model (-1 for unknown)", default = -1)
parser.add_argument('--status_file', type = str, help="which file keeps a record of the status", default = "status.pkl")
parser.add_argument('--result_file', type = str, help="this file keeps the performance of models on testing files", default = "result.pkl")
parser.add_argument('--dump_dir', type = str, help="where to save (state, Pi, num_step) for SL", default = "parameters/")
parser.add_argument('--dump_file', type = str, help="what is the filename to save (state, Pi, num_step) for SL", default="sl.pkl")
parser.add_argument('--train_path', type = str, help='where are training files', default="satProb/mix20_train32/")
parser.add_argument('--test_path', type = str, help='where are test files', default="satProb/mix20_test200/")
parser.add_argument('--max_clause', type = int, help="what is the max_clause", default=120)
parser.add_argument('--max_var', type = int, help="what is the max_var", default=20)
parser.add_argument('--sl_buffer_size', type = int, help="max size of sl buffer", default = 1000000)
parser.add_argument('--nbatch', type = int, help="what is the batch size to use", default = 32)
parser.add_argument('--nstack', type = int, help="how many layers of states to use", default = 1)
parser.add_argument('--nrepeat', type = int, help="how many times to repeat a SAT problem", default= 100)
parser.add_argument('--n_start', type = int, help="which file index to start with (for running)", default = 0)
parser.add_argument('--n_train_files', type = int, help="total number of training files", default = 0) # calculated later
parser.add_argument('--n_test_files', type = int, help="total number of testing files", default = 0) # calculated later
parser.add_argument('--l2_coeff', type = float, help="the coefficient for l2 regularization", default = 0.0001)
parser.add_argument('--sl_num_steps', type = int, help="how many times to do supervised training", default = 64000)
parser.add_argument('--sl_nbatch', type = int, help="what is the batch size for supervised training", default = 32)
parser.add_argument('--sl_ncheckpoint', type = int, help="how often to checkpoint a supervised trained model", default =32000)
parser.add_argument('--n_cycles', type = int, help="how many cycles of self_play -> super_train -> model_ev do we want to run", default = 2)
parser.add_argument('--show_only', type = str, help="if only show the result", default="No")
parser.add_argument('--which_cycle', type = int, help="which cycle are we in now", default = 0)
args = parser.parse_args()
args.n_train_files = len([f for f in os.listdir(args.train_path) if os.path.isfile(os.path.join(args.train_path, f))]) # total number of training files
args.n_test_files = len([f for f in os.listdir(args.test_path) if os.path.isfile(os.path.join(args.test_path, f))]) # total number of testing files
args.dump_dir = args.save_dir # all files related to this project are saved in save_dir, so dump_dir is useless
os.makedirs(args.save_dir, exist_ok = True)
# start the status_track for these operations
status_track = Status()
if os.path.isfile(os.path.join(args.save_dir, args.status_file)):
status_track.start_with(os.path.join(args.save_dir, args.status_file))
else: # otherwise the initial values in Status object fits with the default values here;
status_track.init_with(args.best_model, args.n_start, [], 0, os.path.join(args.save_dir, args.status_file), args)
status_track.show_itself()
# following code evaluates the performance of models on testing files
result_track = Status()
if os.path.isfile(os.path.join(args.save_dir, args.result_file)):
result_track.start_with(os.path.join(args.save_dir, args.result_file))
else: # otherwise initilize values in Status object with the "total model number" --> "length_hist field" of status_track
result_track.init_with(-1, 0, [], 0, os.path.join(args.save_dir, args.result_file))
if args.show_only == "Yes":
status_track.show_itself()
status_track.print_all_models_performance()
result_track.show_itself()
result_track.print_all_models_performance()
return
# build the model for all three functions
built_model = build_model(args, scope = "mcts")
# run a specific file that has bugs
# ev_ss(args, built_model, status_track, 0)
# return
# model_ev(args, built_model, status_track)
# status_track.show_itself()
# return
# result_track.set_same_length_hist(status_track)
# model_ev(args, built_model, result_track, ev_testing = True)
# result_track.show_itself()
# return
# run args.n_cycles number of iteration (self_play -> super_train -> model_ev)
for i in range(args.n_cycles):
args.which_cycle = i
self_play(args, built_model, status_track)
status_track.show_itself()
super_train(args, built_model, status_track)
status_track.show_itself()
model_ev(args, built_model, status_track)
result_track.set_same_length_hist(status_track)
model_ev(args, built_model, result_track, ev_testing = True)
status_track.show_itself()
# print the performance of all models we have so far:
status_track.print_all_models_performance()
result_track.print_all_models_performance()
return
def status(self, status):
self._status = Status(status)
# Python module imports.
import wx
from wx.lib import buttons, scrolledpanel
# relax module imports.
from data_store import Relax_data_store; ds = Relax_data_store()
from graphics import IMAGE_PATH, fetch_icon
from gui.fonts import font
from gui.icons import relax_icons
from gui.interpreter import Interpreter; interpreter = Interpreter()
from gui.misc import add_border, bitmap_setup
from gui.string_conv import float_to_gui, str_to_gui
from lib.check_types import is_float
from lib.errors import RelaxImplementError
from status import Status; status = Status()
# The wx ID for the special accelerator table that allows the ESC button to close relax wizards.
ESC_ID = wx.NewId()
class Wiz_page(wx.Panel):
"""The wizard pages to be placed inside the wizard.
To inherit from this class, you must minimally supply the add_contents() method. This method should build the specific GUI elements. The following methods are also designed to be overwritten:
- add_artwork(), this builds the left hand artwork section of the page.
- add_contents(), this builds the right hand section of the page.
- on_display(), this is executed when the page is displayed.
def execute(self): Db().reset() Status().execute()
"""Script for CPMG relaxation dispersion curve fitting using Dr. Flemming Hansen's data from http://dx.doi.org/10.1021/jp074793o. To run: $ ../../../../../relax --tee relax_disp.log relax_disp.py """ # Python module imports. from os import sep # relax module imports. from auto_analyses.relax_disp import Relax_disp from data_store import Relax_data_store ds = Relax_data_store() from status import Status status = Status() # The dispersion models. MODELS = ['R2eff', 'LM63 3-site'] # The grid search size (the number of increments per dimension). GRID_INC = 11 # The number of Monte Carlo simulations to be used for error analysis at the end of the analysis. MC_NUM = 50 # Create the data pipe. pipe_name = 'base pipe' pipe_bundle = 'relax_disp' pipe.create(pipe_name=pipe_name, bundle=pipe_bundle, pipe_type='relax_disp')
def get_user_status(self):
response = requests.get(url=self.url, params=self.params).json()
return Status(response)
