class CountryInfoBox(Box):
def __init__(self, gameWindow):
super(CountryInfoBox, self).__init__()
self.gameWindow = gameWindow
layout = QGridLayout(self)
layout.setSpacing(0)
layout.setContentsMargins(0, 0, 0, 0)
self.img = QLabel()
self.info = Info()
self.info.textTemplate = '%s'
layout.addWidget(self.img, 0, 0, Qt.AlignHCenter)
layout.addWidget(self.info, 1, 0, Qt.AlignHCenter)
self.info.updateInfo([(' ' * 7, ' ' * 10) for dummy in range(4)])
def updateCountry(self, country):
gameView = self.gameWindow.gameView.gameView
playerName = 'Neutral'
weapon = 0
for player in self.gameWindow.game.players:
if player.id == gameView.gameMap.owner[country]:
playerName = player.name
weapon = player.weapon
image = gameView.countries[country].normal
self.img.setPixmap(QPixmap(image))
if len(playerName) > 10:
playerName = playerName[:7] + '...'
else:
playerName = playerName + ' ' * (10 - len(playerName))
info = [('Owner', playerName),
('Weapon', str(int(weapon))),
('Defense', str(gameView.gameMap.defense[country])),
('Area', str(gameView.gameMap.area[country]))]
self.info.updateInfo(info)
def reply(self, data, cb):
info = data
if not isinstance(data, Info):
info = Info(data)
if not self.config.get('keepBlank', False) and info.text:
info.text = info.text.trim()
rule_list = self.routes
waiter = self.wait_rules.get(info.user, None)
if waiter:
rule_list = [].extend(waiter).extend(self.routes)
self.last_wait_rules[info.user] = waiter
self.wait_rules[info.user] = None
for i in range(0, len(rule_list)):
rule = rule_list[i]
if Rule.is_match(info, rule):
weixinlogger.info("match %s" % rule.name)
conversationlogger.info("match %s" % rule.name)
rule.count = i
result = Rule.execute(info, rule, cb)
if isinstance(result, (str, unicode)):
result = BuildConfig(MessageBuilder.TYPE_RAW_TEXT, None, result)
if result:
if rule.replies:
self.wait(info.user, Rule.convert(rule.replies, rule.name))
return cb(None, result)
else:
logger.debug("not match %s" % rule.name)
return cb('404', BuildConfig(MessageBuilder.TYPE_RAW_TEXT, None, self.get_status('404') + info.text))
def __init__(self,
bam,
bed,
info,
out,
analytical_threshold=ANALYTICAL_THRESHOLD):
self.bam = bam
self.bed = bed
self.info = info
self.out = out
self.analytical_threshold = analytical_threshold
# Init
self.bed_obj = Bed(self.bed)
self.info_obj = Info(self.info)
self.mh_dict = {}
self.filters_obj = Filters(
analytical_threshold=self.analytical_threshold,
abs_analytical_threshold=self.ABSOLUTE_ANALYTICAL_THRESHOLD,
min_mapq=self.MIN_MAPPING_QUALITY,
max_mapq=self.MAX_MAPPING_QUALITY,
remove_deletions=self.REMOVE_DELETIONS)
self.short_reads_count = 0
self.total_reads_count = 0
self.number_of_contributors_overall = 0
def updateuser(username, userright, userwrong, usertimeduring, userchoicelog):
userid = db.session.query(
User.user_id).filter(User.user_username == username).first()
if userid:
userid = userid[0]
lastlog = db.session.query(UserLog).filter(
and_(UserLog.userlog_userid == userid,
UserLog.userlog_status == 0)).first()
if lastlog:
db.session.query(UserLog).filter(
UserLog.userlog_userid == userid, ).update(
{"userlog_status": 1})
userlog_userid = userid
userlog_right = userright
userlog_wrong = userwrong
userlog_timeduring = usertimeduring
userlog_status = 0
userlog_choicelog = userchoicelog
ul = UserLog(userlog_userid, userlog_right, userlog_wrong,
userlog_timeduring, userlog_status, userlog_choicelog)
try:
db.session.add(ul)
db.session.commit()
except Exception as e:
print(e)
return Info(False, "考试数据提交失败，请联系系统管理员！（" + str(userlog_choicelog) +
"）").todict()
else:
return Info(True, "考试数据提交成功", {
"userlog_timeduring": userlog_timeduring
}).todict()
else:
return Info(False, "非法的用户名").todict()
def rozdaj_karty(self):
Info.rozdanie_kart()
for x in range(2):
for gracz in self.gracze:
i = randint(0, len(self.talia)-1)
gracz.reka.dobierz(self.talia[i])
self.talia.pop(i)
def run(self):
try:
self._prepare.create_folder()
StepTimes().add(
'preparation_start'
) # TODO writes to old directory because does not exist yet
Info().status = "preperation_start"
self._prepare.execute()
logging.info('End of Preparation')
#StepTimes().add('preparation_start')
StepTimes().add('simulation_start')
logging.info('Start of simulation')
self._system_monitor.start()
self._event.execute(
timeout=25) # TODO check if timeout works as expected
self._system_monitor.exit()
logging.info('End of simulation')
StepTimes().add('postprocessing_start')
self._postprocessing.execute()
StepTimes().add('postprocessing_end')
except Exception as exce:
Info().status = f"failed with {exce}"
self._postprocessing.clean_up_docker_safe()
raise exce
def main():
output_type = "brief" # default
#Print the welcome message:
print("Welcome to this searcher!")
print("To quit, please enter ::quit")
conn = Connection()
conn.connect()
cursors = conn.get_cursors()
quit = False
while not quit:
query = input("(Searcher)>>> ").lower()
if query == "::quit":
print("Thank you for using our service")
conn.close()
break
elif query == "output=breif":
output_type = "brief"
elif query == "output=full":
output_type = "full"
else:
try:
info = Info(query, cursors, output_type)
info.execute_query()
except Exception:
print("No matches found!")
class CountryInfoBox(Box):
def __init__(self, gameWindow):
super(CountryInfoBox, self).__init__()
self.gameWindow = gameWindow
layout = QGridLayout(self)
layout.setSpacing(0)
layout.setContentsMargins(0, 0, 0, 0)
self.img = QLabel()
self.info = Info()
self.info.textTemplate = '%s'
layout.addWidget(self.img, 0, 0, Qt.AlignHCenter)
layout.addWidget(self.info, 1, 0, Qt.AlignHCenter)
self.info.updateInfo([(' ' * 7, ' ' * 10) for dummy in range(4)])
def updateCountry(self, country):
gameView = self.gameWindow.gameView.gameView
playerName = 'Neutral'
weapon = 0
for player in self.gameWindow.game.players:
if player.id == gameView.gameMap.owner[country]:
playerName = player.name
weapon = player.weapon
image = gameView.countries[country].normal
self.img.setPixmap(QPixmap(image))
if len(playerName) > 10:
playerName = playerName[:7] + '...'
else:
playerName = playerName + ' ' * (10 - len(playerName))
info = [('Owner', playerName), ('Weapon', str(int(weapon))),
('Defense', str(gameView.gameMap.defense[country])),
('Area', str(gameView.gameMap.area[country]))]
self.info.updateInfo(info)
def __init__(self):
# initializes game session and builds game resourses
pygame.init()
self.settings = Settings()
# storing game statistics
self.stats = Stats(self)
self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
self.screen_rect = self.screen.get_rect()
self.settings.screen_width = self.screen.get_rect().width
self.settings.screen_height = self.screen.get_rect().height
pygame.display.set_caption("Warplanes")
self.bg_color = self.settings.bg_colour
self.hp = self.settings.enemy_hp
self.junkers = Junkers(self)
self.shots = pygame.sprite.Group()
self.enemy_shots = pygame.sprite.Group()
self.enemies = pygame.sprite.Group()
# game scoreboard
self.sb = Scoreboard(self)
self.play_button = Button(self, "START", (0, -100))
self.info_button = Button(self, "INFO", (0, 100))
self.pause_button = Button(self, "Continue")
self._create_sky()
self.info = Info(self)
pygame.mixer.music.load('music.wav')
self.shot_sound = pygame.mixer.Sound('shot.ogg')
self.explosion_sound = pygame.mixer.Sound('explosion.ogg')
def OneCnn():
brain = Brain()
brain = brain.getInstance('cnn', 'log/cat_vs_dog/train/')
from info import Info
info = Info()
image_info = info.getOneImage('data/cat_vs_dog/test/dog.9712.jpg')
brain.evaluateOneImage(image_info, 2, {'cat': 0, 'dog': 1})
def trainCnn():
brain = Brain()
brain = brain.getInstance('cnn', 'log/cat_vs_dog/train/')
train_dir = 'data/cat_vs_dog/train/'
from info import Info
info = Info()
train_batch, train_label_batch = info.getImages(train_dir, {'cat' : 0, 'dog' : 1})
brain.trainCnnNetwork(train_batch, train_label_batch)
def selected(self):
items = self.tableWidget.selectedItems()
if not items:
return
self.tableWidget.clearSelection()
self.inf = Info(items[0].data(QtCore.Qt.UserRole))
self.inf.show()
def entrust(self):
"""委托单
委托状态：已报、部成、已报待撤、部成待撤、未报、待报、已成、已撤、部撤、废单
"""
info = Info('entrust', self.broker)
information = self.user.entrust()
info.format(information)
return info
def initstudents():
try:
db.session.query(UserLog).update({"userlog_status": 1})
db.session.commit()
except Exception as e:
print(e)
return Info(False, "初始化失败！" + str(e)).todict()
else:
return Info(True, "初始化成功！").todict()
def __init__(self, event_id, log_level, when, who, do_what, what, how_much, with_whom):
Info.__init__(self, event_id, self.__class__.__name__)
self.log_level = log_level
self.when = when
self.who = who
self.do_what = do_what
self.what = what
self.how_much = how_much
self.with_whom = with_whom
def check_available_cancels(self, parsed=True):
"""
@Contact: Emptyset <*****@*****.**>
检查撤单列表
"""
info = Info('entrust', self.broker)
information = self.user.check_available_cancels(parsed)
info.format(information)
return info
def removeproblems(problem_id):
pr = db.session.query(Problem).filter(
Problem.problem_id == problem_id).first()
if pr:
db.session.delete(pr)
db.session.commit()
return Info(True, "删除成功！").todict()
else:
return Info(False, "不存在的题号！").todict()
def __init__(self):
self.window = Tk()
self.window.protocol("WM_DELETE_WINDOW", self.finishApp)
self.window.title('Herramienta de prueba para la predicción')
ico = PhotoImage(file=os.path.abspath('.') + '/Activos/term.png')
self.window.call('wm', 'iconphoto', self.window._w, ico)
self.window.config(bg=mainColor)
self.window.attributes("-zoomed", False)
self.window.minsize(width=300, height=300)
#Peso 100% en self.window
self.window.grid_rowconfigure(0, weight=1)
self.window.grid_columnconfigure(0, weight=1)
#Ventana principal fija sin ajuste de tamaño
self.window.resizable(False, False)
#Centrar ventana en función de las dimendsiones del contenedor de inicio
self.center(450, 490)
self.view = Window(self.window)
self.functions = Functions()
self.infoW = Info(self.view.dataContainer)
self.genDataW = GenData(self.view.dataContainer)
self.predW = Predictions(self.view.dataContainer)
self.graphsW = Graphs(self.view.dataContainer)
#Botones de las acciones del usuario
self.view.buttonDisconnect.bind("<Button>", self.disconnect)
self.view.buttonToBD.bind("<Button>", self.changeToConnect)
self.view.buttonConnect.bind("<Button>", self.checkConnection)
self.view.infoButton.bind(
"<Button>", lambda event: self.switchSelector(
self.view.predButton, self.view.graphButton, self.view.
genDataButton, self.view.infoButton, 1))
self.view.genDataButton.bind(
"<Button>", lambda event: self.switchSelector(
self.view.infoButton, self.view.predButton, self.view.
graphButton, self.view.genDataButton, 2))
self.view.predButton.bind(
"<Button>", lambda event: self.switchSelector(
self.view.infoButton, self.view.graphButton, self.view.
genDataButton, self.view.predButton, 3))
self.view.graphButton.bind(
"<Button>", lambda event: self.switchSelector(
self.view.infoButton, self.view.genDataButton, self.view.
predButton, self.view.graphButton, 4))
self.genDataW.buttonFilterData.bind("<Button>",
lambda event: self.getNewGenData())
self.graphsW.buttonGetGraph.bind("<Button>",
lambda event: self.getGraphsData())
self.predW.buttonForecast.bind("<Button>", self.getForecast)
self.predW.butHistForecast.bind("<Button>", self.getHistForecast)
#Ventana principal actualizaciones
self.window.mainloop()
def studentregitster(username, password):
us = db.session.query(User).filter(
User.user_username == username, ).first()
if us:
return Info(False, "已存在的用户名！").todict()
else:
user = User(username, password)
db.session.add(user)
db.session.commit()
return Info(True, "注册成功！").todict()
def cancel_all_entrust(self):
"""
撤单所有委托
"""
#if 'ht' != self.broker:
# return False
info = Info('cancel', self.broker)
information = self.user.cancel_all_entrust()
info.format(information)
return info
def __init__(self):
bot_name = "Swarming"
self.game = hlt.Game(bot_name)
logging.info("Starting bot {}".format(bot_name))
self.pathfinder = Pathfinder()
self.info = Info()
self.ai = AI(self.info, self.pathfinder)
self.game_map = None
def __init__(self, parent=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(MainWindow, self).__init__(parent)
self.setupUi(self)
self.info = Info()
def get_port_list(sheet):
port_list = []
pattern = re.compile('\d+')
s = Info("Get Ports list")
for port in sheet.iter_rows(2, sheet.max_row):
str = port[3].value
p = re.match(pattern, str)
port_list.append(p.group(0))
# print(p.group(0))
s.out_end()
return port_list
def __init__(self, gameWindow):
super(CountryInfoBox, self).__init__()
self.gameWindow = gameWindow
layout = QGridLayout(self)
layout.setSpacing(0)
layout.setContentsMargins(0, 0, 0, 0)
self.img = QLabel()
self.info = Info()
self.info.textTemplate = '%s'
layout.addWidget(self.img, 0, 0, Qt.AlignHCenter)
layout.addWidget(self.info, 1, 0, Qt.AlignHCenter)
self.info.updateInfo([(' ' * 7, ' ' * 10) for dummy in range(4)])
def cancel_entrust(self, entrust_no, stock_code = ''):
"""撤单
:param entrust_no: 委托单号
"""
info = Info('cancel', self.broker)
if self.broker == 'yh':
information = self.user.cancel_entrust(entrust_no, stock_code)
elif self.broker == 'xq':
#xueqiu cancel 接口不可用
information = self.user.cancel_entrust(entrust_no, stock_code)
info.format(information)
return info
def modifypassword(oldpassword, newpassword, username):
ad = db.session.query(Admin).filter(
and_(Admin.admin_username == username,
Admin.admin_password == oldpassword)).first()
if not ad:
return Info(False, "原密码错误！").todict()
else:
db.session.query(Admin).filter(
Admin.admin_username == username).update(
{"admin_password": newpassword})
db.session.commit()
return Info(True, "密码修改成功！").todict()
def _make_info(self):
if self._info is None:
self._info = Info()
self._copy_style_from_view([self._info, self._info.text_view])
self._info_revealer.add(self._info)
self._info.show()
self._info_revealer.show()
self._info_revealer.set_reveal_child(True)
self._info.connect('destroy', self._on_info_destroy)
def load_data(self, info: Info, csv_path: str, encoding: str):
print("Завантажуємо основний файл")
arr2 = []
try:
with open(csv_path, newline='', encoding=encoding) as f:
reader = csv.reader(f)
for row in reader:
curr_row = row[0].split(';')
arr2.extend([curr_row])
info.set_information(arr2)
print("input-csv <" + csv_path + ">: OK")
except Exception:
print("***** program aborted *****")
print("Problem in load data")
def main():
try:
info = Info()
time.sleep(1)
info.retrieve_info()
except EOFError:
print("\nRun this Docker image with -it!")
sys.exit(-2)
except KeyboardInterrupt:
print("\nControl + C has been invoked!")
sys.exit(-3)
except Exception:
print("\nSomething went wrong!")
sys.exit(-1)
def get_deal(self, date=None):
"""
@Contact: Emptyset <*****@*****.**>
获取历史日成交列表
e.g.: get_deal( "2016-07-14" )
如果不传递日期则取的是当天成交列表
返回值格式与get_current_deal相同
遇到提示“系统超时请重新登录”或者https返回状态码非200或者其他异常情况会返回False
"""
c = Checker()
info = Info('deal', self.broker)
information = self.user.get_deal(date)
info.format(information)
return info
def wybor(self):
print(
"-----------------------------------------------------------------"
)
bet = "ALL-IN" if self.rozdanie.najwiekszy_zaklad >= self.zaklad + self.saldo else "BET"
wybor_flag = False
while not wybor_flag:
Info.wyswietl_karty_gracza(self)
akcja = input(
f" PASS || ALL || BET *kwota* \t or \t P || A || B *kwota*\n \t"
).upper()
if akcja == "PASS" or akcja == "P":
self.passuje = True
wybor_flag = True
### ERROR GDY SIE NIE PODA LICZBY, INPUT TYPU 9-1 DAJE LICZBE 91 ###
elif akcja[0] == "B" or akcja[0:3] == "BET":
# Zamienia na ladna liczbe
wartosc = int("".join([str(x) for x in akcja if x.isdigit()]))
if self.rozdanie.najwiekszy_zaklad > wartosc:
Info.minimalna_stawka_error(
self.rozdanie.najwiekszy_zaklad)
else:
if self.bet(wartosc):
wybor_flag = True
else:
Info.za_maly_budzet()
elif akcja == "ALL" or akcja == "A" or akcja == "ALL-IN":
self.bet(self.saldo + self.zaklad)
self.all_in = True
wybor_flag = True
else:
Info.zla_akcja()
print("\n")
def setsuccessjson(param):
if 'code' and 'data' in param:
code = param['code']
param = param['data']
info = Info()
response = {
'status': code,
'meta': info.get(),
'result': param
}
return response
return {
'status': 500,
'message': 'Something went wrong!!'
}
def __init__(self, name):
# Note that the below condition should fail if this __ini__ condition is called from a derived class, as self.__class__.__name__ should be the daughter class name!
if self.__class__.__name__ == "Events":
AdvPrint.cerr_exit("Internal error: Instance of abstract base class 'Events' created!")
self.name = name
Info.book_events(self) # sets identifier
self.processed = False
self.analysis_result_files = dict()
self.analysis_signal_files = dict()
self.analysis_cutflow_files = dict()
self.maxEvents = -1
self.result_output_file = ""
self.fritz_config_file = ""
def get_resultCollectors(self):
""" Gathers results from all events"""
# setup resultCollector object
resultCollectors_pr = dict()
for analysis in Info.analyses:
resultCollectors_pr[analysis] = dict()
signal_regions = Info.get_analysis_parameters(analysis)["signal_regions"]
for sr in signal_regions:
resultCollectors_pr[analysis][sr] = ResultCollector(self.name, analysis, sr)
# loop over all associated events and average results in all resultCollectors
for event in self.eventsList:
resultCollectors_ev = event.get_resultCollectors()
for analysis in resultCollectors_pr:
for sr in resultCollectors_pr[analysis]:
resultCollectors_pr[analysis][sr].add_and_average(resultCollectors_ev[analysis][sr])
# Write process file, if wanted
if Info.parameters["ProcessResultFileColumns"] != []:
AdvPrint.mute()
AdvPrint.set_cout_file(self.result_output_file, True)
for col in Info.parameters["ProcessResultFileColumns"]:
AdvPrint.cout(col+" ", "nlb")
AdvPrint.cout("")
for a in sorted(resultCollectors_pr.keys()):
for sr in sorted(resultCollectors_pr[a].keys()):
AdvPrint.cout(resultCollectors_pr[a][sr].line_from_data(Info.parameters["ProcessResultFileColumns"]))
AdvPrint.format_columnated_file(self.result_output_file)
AdvPrint.set_cout_file("#None")
AdvPrint.unmute()
return resultCollectors_pr
def prepare_run(self):
"""Creates all output folders and files and generate cards that are needed"""
Info.prepare_config()
# preparation only needed if new run is started with "overwrite"
DetectorSettings.merge_settings()
if Info.parameters["outputexists"] == "overwrite" or not os.path.isdir(Info.paths['output']):
Info.prepare_output_directories()
DetectorSettings.update_delphes_files()
else:
# If the original run used modified Delphes settings, we need them for the added run as well
atlas_conf_new = os.path.join(Info.paths['output_delphes'], "modified_ATLAS_card.tcl")
cms_conf_new = os.path.join(Info.paths['output_delphes'], "modified_CMS_card.tcl")
if os.path.isfile(atlas_conf_new):
Info.files['delphes_global_config_ATLAS'] = atlas_conf_new
if os.path.isfile(cms_conf_new):
Info.files['delphes_global_config_CMS'] = cms_conf_new
def linkAnalysis(self,link):
temp=link.find("a")
address=temp["href"]
brief=temp["title"]
print 'link address is : ',address
# print 'link content is :', brief
timenow=link.find(attrs={"class":"date"}).string
# print timenow
y=timenow[0:4]
m=timenow[5:7]
d=timenow[8:10]
second=timenow[12:20]
timenow=y+'-'+m+'-'+d+' '+second
# print timenow
now= time.strptime(timenow, '%Y-%m-%d %H:%M:%S')
if time.mktime(now)<time.mktime(self.updateTime):
return 0
childSoup=self.getChildSoup(address)
try:
newsContent=childSoup.find(attrs={"class":"art_main"})
except:
newsContent=None
stringTemp=""
if not newsContent:
return 1
for content in newsContent:
stringTemp+=str(content)
# print stringTemp
# print searchdict
tags=self.searchTag(stringTemp)
# print 'tags is ',tags
if tags:
newin=Info()
newin.addLink(address,brief)
for tag in tags:
newin.addTag(tag)
print 'in this news find ',tag
self.addInfo(newin)
print '------------------------- one link analysis end ','------------------'
return 1
def prepareFritzInputFile(self, config, events):
config, secname = events.prepareFritzInputFile(config)
# if cross section is provided, override config
if self.have_xsect:
config.set(secname, "xsect", str(self.xsec*Info.unit(self.xsec_unit)))
if self.have_xerr:
if self.xerr_unit == "%":
config.set(secname, "xsectErrFactor", str(self.xerr/100.))
else:
config.set(secname, "xsectErr", str(self.xerr*Info.unit(self.xerr_unit)))
else: # fritz wants this, lets give it to him
config.set(secname, "xsectErr", str(0))
if self.have_kfac:
config.set(secname, "kfactor", str(self.kfac))
return config
def linkAnalysis(self,link):
temp=link.findAll("a")
dat=link.findAll("span")
i=0
for da in dat:
strtemp=da.string
if strtemp.find(':')==-1:
return
else:
address='http://stock.cfi.cn/'+temp[i]["href"]
brief=temp[i].string
t=time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))
truetime=t[0:11]+strtemp+':59'
now= time.strptime(truetime, '%Y-%m-%d %H:%M:%S')
if time.mktime(now)<time.mktime(self.updateTime):
return
else :
print 'link address is : ',address
childSoup=self.getChildSoup(address)
try:
newsContent=childSoup.find(attrs={"id":"tdcontent"})
except:
newsContent=None
stringTemp=""
if not newsContent:
return
for content in newsContent:
stringTemp+=str(content)
tags=self.searchTag(stringTemp)
if tags:
newin=Info()
newin.addLink(address,brief)
for tag in tags:
newin.addTag(tag)
print 'in this news find ',tag
self.addInfo(newin)
print '------------------------- one link analysis end ','------------------'
i+=1
def __init__(self, gameWindow):
super(CountryInfoBox, self).__init__()
self.gameWindow = gameWindow
layout = QGridLayout(self)
layout.setSpacing(0)
layout.setContentsMargins(0, 0, 0, 0)
self.img = QLabel()
self.info = Info()
self.info.textTemplate = '%s'
layout.addWidget(self.img, 0, 0, Qt.AlignHCenter)
layout.addWidget(self.info, 1, 0, Qt.AlignHCenter)
self.info.updateInfo([(' ' * 7, ' ' * 10) for dummy in range(4)])
def drawSprites():
global mushrooms, ploppers, snakes, spiders, gamePaused, gamePlaying
for f in range(len(mushrooms)):
mushrooms[f].draw(window)
for f in range(len(ploppers)):
ploppers[f].draw(window)
if gamePlaying:
player.draw(window)
for f in range(len(snakes)):
snakes[f].draw(window)
for f in range(len(spiders)):
spiders[f].draw(window, fontSmaller)
if gamePaused:
gamePaused = Info(130, 280, pygame.image.load(os.path.join("centipede", "paused.png")))
gamePaused.draw(window)
def _make_info(self):
if self._info is None:
self._info = Info()
self._copy_style_from_view([self._info, self._info.text_view])
self._info_revealer.add(self._info)
self._info.show()
self._info_revealer.show()
self._info_revealer.set_reveal_child(True)
self._info.connect('destroy', self._on_info_destroy)
def __init__(self):
#global Info, AdvPrint
""" Initialisation of a CheckMATE object leads to an entire run of the CheckMATE procedure"""
# Initialisation steps
#Info.init()
Info.fill_standard_paths_and_files()
if len(sys.argv) == 1:
self.printUsage()
self.printLogo()
if len(sys.argv) == 2 and sys.argv[-1] != "-h":
Info.fill_info_from_file(sys.argv[1])
self.procList = Info.fill_processes_from_file(sys.argv[1])
else:
Info.fill_info_from_parameters()
self.procList = Info.fill_processes_from_parameters()
if Info.parameters["outputexists"] == "add":
self.load(Info.files['internal_processes'])
for p in self.procList:
p.checkInputConsistency()
self.user_param_check()
self.prepare_run()
# Running the event-based part
if self.procList == []:
AdvPrint.cerr_exit("No processes are loaded!")
for p in self.procList:
p.prepare()
p.run()
AdvPrint.cout("\n")
# Evaluate
if not Info.flags['skipevaluation']:
self.evaluate()
# Store internal status
Info.save(Info.files['internal_info'])
self.save(Info.files['internal_processes'])
def linkAnalysis(self,link):
temp=link.find("a")
address=temp["href"]
brief=temp["title"]
timenow=link.find("span").string
timenow+=":59"
now= time.strptime(timenow, '%Y-%m-%d %H:%M:%S')
# print 'news time:',timenow,'and last update time :',self.updateTime
if time.mktime(now)<time.mktime(self.updateTime):
return 0
print 'link address is : ',address
childSoup=self.getChildSoup(address)
try:
newsContent=childSoup.find(attrs={"class":"Body","id":"ContentBody"})
except:
newsContent=None
stringTemp=""
if newsContent==None:
return 1
for content in newsContent:
stringTemp+=str(content)
tags=self.searchTag(stringTemp)
if tags:
newin=Info()
newin.addLink(address,brief)
for tag in tags:
newin.addTag(tag)
print 'in this news find ',tag
self.addInfo(newin)
print '------------------------- one link analysis end -------------------------'
return 1
def prepareFritzInputFile(self, fritzconfig):
fritzconfig, secname = Pythia8Events.prepareFritzInputFile(self, fritzconfig)
if Info.files['py8rndm'] != '':
fritzconfig.set(secname,"rndmIn",Info.files['py8rndm'])
fritzconfig.set(secname, "useMG5","true")
fritzconfig.set(secname, "mgProcCard",self.mg5_cards["proc"])
if self.mg5_cards["run"] != "" :
fritzconfig.set(secname, "mgRunCard",self.mg5_cards["run"])
if self.mg5_cards["param"] != "" :
fritzconfig.set(secname, "mgParamCard",self.mg5_cards["param"])
if self.mg5_cards["config"] != "" :
fritzconfig.set(secname, "mgConfigCard",self.mg5_cards["config"])
fritzconfig.set(secname, "mgRunPath",os.path.join(Info.paths['output_mg5'], self.identifier))
fritzconfig.set(secname, "mgSourcePath",Info.paths['mg5_source_path'])
if self.have_xsth:
fritzconfig.set(secname, "xsectthresh",self.xsth*Info.unit(self.xsth_unit)/Info.unit('pb')) # pythia calculates in pb
return fritzconfig, secname
def get_resultCollectors(self):
""" Finds the results of all events within all processes and sums and averages them """
#setup resultCollector object
resultCollectors_tot = dict()
for analysis in Info.analyses:
resultCollectors_tot[analysis] = dict()
signal_regions = Info.get_analysis_parameters(analysis)["signal_regions"]
for sr in signal_regions:
resultCollectors_tot[analysis][sr] = ResultCollector("total", analysis, sr)
# loop over all associated processes
for proc in self.procList:
# process results are summed
resultCollectors_proc = proc.get_resultCollectors()
for analysis in resultCollectors_tot:
for sr in resultCollectors_tot[analysis]:
resultCollectors_tot[analysis][sr].add_and_sum(resultCollectors_proc[analysis][sr])
return resultCollectors_tot
def _config_experiment(config, experiment):
exists = False # are there any analyses for this experiment?
parameters = dict()
for analysis in Info.analyses:
params = Info.get_analysis_parameters(analysis)
if params["experiment"] != experiment:
continue
exists = True
parameters[analysis] = params
section_name = _analysis_section_name(analysis)
config.add_section(section_name)
config.set(section_name, "analysishandler", experiment)
if not exists:
# no analyses found.
return
_filter_jettags(config, parameters, experiment, experiment)
_filter_isolation(config, parameters, "electron", "ELECTRONISO", experiment, experiment)
_filter_isolation(config, parameters, "muon", "MUONISO", experiment, experiment)
_filter_isolation(config, parameters, "photon", "PHOTONISO", experiment, experiment)
def load_expdata(self):
analysis = self.resultCollector.analysis
if analysis == "":
return # for pseudo-evaluators
sr = self.resultCollector.sr
parameters = Info.get_analysis_parameters(analysis)
# S95 comparison: r value compares lower s95 limit on s (which is almost 2 sigma) to the model independent limit
if sr not in parameters["reference_data"]:
AdvPrint.cerr_exit("evaluator::load_expdata unknown signal region "+analysis+" - "+sr)
if "S95_obs" not in parameters["reference_data"][sr]:
AdvPrint.cerr_exit("evaluator::load_expdata S95_obs value is unknown for "+analysis+" - "+sr)
self.s95_obs = float(parameters["reference_data"][sr]["S95_obs"])
# If no expected upper limit is given, observed limit is used
if "S95_exp" not in parameters["reference_data"][sr]:
self.s95_exp = self.s95_obs
self.warnings.append("No expected limit could be found in reference data. Using expected = observed.")
else:
self.s95_exp = float(parameters["reference_data"][sr]["S95_exp"])
if "obs" not in parameters["reference_data"][sr]:
AdvPrint.cerr_exit("evaluator::load_expdata 'obs' is unknown for "+analysis+" - "+sr)
self.obs = float(parameters["reference_data"][sr]["obs"])
if "bkg" not in parameters["reference_data"][sr]:
AdvPrint.cerr_exit("evaluator::load_expdata 'bkg' is unknown for "+analysis+" - "+sr)
self.bkg = float(parameters["reference_data"][sr]["bkg"])
self.bkg_err = -1
if "bkg_err" in parameters["reference_data"][sr]:
self.bkg_err = float(parameters["reference_data"][sr]["bkg_err"])
elif "bkg_errp" in parameters["reference_data"][sr]:
# Asymmetric error: as a rough approximation, use the mean of the squares
self.bkg_err = sqrt(float(parameters["reference_data"][sr]["bkg_errp"])**2 + float(parameters["reference_data"][sr]["bkg_errm"])**2)/sqrt(2.)
elif "bkg_err_sys" in parameters["reference_data"][sr]:
# Total error = independent quadratic sum of statistical and systematical component
self.bkg_err = sqrt(float(parameters["reference_data"][sr]["bkg_err_stat"])**2 + float(parameters["reference_data"][sr]["bkg_err_sys"])**2 )
elif "bkg_err_sysp" in parameters["reference_data"][sr]:
self.bkg_err = sqrt(float(parameters["reference_data"][sr]["bkg_err_stat"])**2 + (float(parameters["reference_data"][sr]["bkg_err_sysp"])**2)/2. + (float(parameters["reference_data"][sr]["bkg_err_sysp"])**2)/2.)
def calc_likelihood(self):
""" Calculates approximate likelihood using the root-find method """
analysis = self.resultCollector.analysis
sr = self.resultCollector.sr
parameters = Info.get_analysis_parameters(analysis)
# Determine parameters
sig = float(self.resultCollector.signal_normevents)
sig_err = float(self.resultCollector.signal_err_tot)
obs = float(parameters["reference_data"][sr]["obs"])
bkg = float(parameters["reference_data"][sr]["bkg"])
bkg_err = 0
if "bkg_err" in parameters["reference_data"][sr]:
bkg_err = float(parameters["reference_data"][sr]["bkg_err"])
elif "bkg_errp" in parameters["reference_data"][sr]:
# Asymmetric error: as a rough approximation, use the mean of the squares
bkg_err = sqrt(float(parameters["reference_data"][sr]["bkg_errp"])**2 + float(parameters["reference_data"][sr]["bkg_errm"])**2)/sqrt(2.)
elif "bkg_err_sys" in parameters["reference_data"][sr]:
# Total error = independent quadratic sum of statistical and systematical component
bkg_err = sqrt(float(parameters["reference_data"][sr]["bkg_err_stat"])**2 + float(parameters["reference_data"][sr]["bkg_err_sys"])**2 )
elif "bkg_err_sysp" in parameters["reference_data"][sr]:
bkg_err = sqrt(float(parameters["reference_data"][sr]["bkg_err_stat"])**2 + (float(parameters["reference_data"][sr]["bkg_err_sysp"])**2)/2. + (float(parameters["reference_data"][sr]["bkg_err_sysp"])**2)/2.)
self.likelihood = likelihood(1.0, obs, bkg, sig, bkg_err, sig_err, [0.0,0.0])
class Entry(Gtk.EventBox):
__gtype_name__ = "CommanderEntry"
def __init__(self, view):
Gtk.EventBox.__init__(self)
self._view = view
self.set_visible_window(False)
hbox = Gtk.Box.new(Gtk.Orientation.HORIZONTAL, 3)
hbox.show()
hbox.set_border_width(3)
# context for the view
self._entry = Gtk.Entry()
self._entry.set_has_frame(False)
self._entry.set_name("gedit-commander-entry")
self._entry.show()
css = Gtk.CssProvider()
css.load_from_data(
bytes(
"""
@binding-set terminal-like-bindings {
unbind "<Control>A";
bind "<Control>W" { "delete-from-cursor" (word-ends, -1) };
bind "<Control>A" { "move-cursor" (buffer-ends, -1, 0) };
bind "<Control>U" { "delete-from-cursor" (display-line-ends, -1) };
bind "<Control>K" { "delete-from-cursor" (display-line-ends, 1) };
bind "<Control>E" { "move-cursor" (buffer-ends, 1, 0) };
bind "Escape" { "delete-from-cursor" (display-lines, 1) };
}
GtkEntry#gedit-commander-entry {
gtk-key-bindings: terminal-like-bindings;
/* Override background to anything. This is weird, but doing this we can
then in code use widget.override_background to set the color dynamically
to the same color as the gedit view */
background: transparent;
border-width: 0;
box-shadow: 0 0 transparent;
transition: none;
}
""",
"utf-8",
)
)
# FIXME: remove hardcopy of 600 (GTK_STYLE_PROVIDER_PRIORITY_APPLICATION)
# https://bugzilla.gnome.org/show_bug.cgi?id=646860
self._entry.get_style_context().add_provider(css, 600)
self._prompt_label = Gtk.Label(label="<b>>>></b>", use_markup=True)
self._prompt_label.show()
self._entry.connect("focus-out-event", self.on_entry_focus_out)
self._entry.connect("key-press-event", self.on_entry_key_press)
self._history = History(os.path.join(GLib.get_user_config_dir(), "gedit/commander/history"))
self._prompt = None
self._accel_group = None
hbox.pack_start(self._prompt_label, False, False, 0)
hbox.pack_start(self._entry, True, True, 0)
self.copy_style_from_view()
self.view_style_updated_id = self._view.connect("style-updated", self.on_view_style_updated)
self.add(hbox)
self.attach()
self._entry.grab_focus()
self._wait_timeout = 0
self._info_window = None
self.connect("destroy", self.on_destroy)
self.connect_after("size-allocate", self.on_size_allocate)
self.view_draw_id = self._view.connect_after("draw", self.on_draw)
self._history_prefix = None
self._suspended = None
self._handlers = [
[0, Gdk.KEY_Up, self.on_history_move, -1],
[0, Gdk.KEY_Down, self.on_history_move, 1],
[None, Gdk.KEY_Return, self.on_execute, None],
[None, Gdk.KEY_KP_Enter, self.on_execute, None],
[0, Gdk.KEY_Tab, self.on_complete, None],
[0, Gdk.KEY_ISO_Left_Tab, self.on_complete, None],
]
self._re_complete = re.compile("(\"((?:\\\\\"|[^\"])*)\"?|'((?:\\\\'|[^'])*)'?|[^\s]+)")
self._command_state = commands.Commands.State()
def on_view_style_updated(self, widget):
self.copy_style_from_view()
def get_border_color(self):
color = self.get_background_color().copy()
color.red = 1 - color.red
color.green = 1 - color.green
color.blue = 1 - color.blue
color.alpha = 0.5
return color
def get_background_color(self):
context = self._view.get_style_context()
return context.get_background_color(Gtk.StateFlags.NORMAL)
def get_foreground_color(self):
context = self._view.get_style_context()
return context.get_color(Gtk.StateFlags.NORMAL)
def get_font(self):
context = self._view.get_style_context()
return context.get_font(Gtk.StateFlags.NORMAL)
def copy_style_from_view(self, widget=None):
if widget != None:
context = self._view.get_style_context()
font = context.get_font(Gtk.StateFlags.NORMAL)
widget.override_color(Gtk.StateFlags.NORMAL, self.get_foreground_color())
widget.override_font(self.get_font())
else:
if self._entry:
self.copy_style_from_view(self._entry)
if self._prompt_label:
self.copy_style_from_view(self._prompt_label)
def view(self):
return self._view
def on_size_allocate(self, widget, alloc):
alloc = self.get_allocation()
self._view.set_border_window_size(Gtk.TextWindowType.BOTTOM, alloc.height)
win = self._view.get_window(Gtk.TextWindowType.BOTTOM)
self.set_size_request(win.get_width(), -1)
# NOTE: we need to do this explicitly somehow, otherwise the window
# size will not be updated unless something else happens, not exactly
# sure what. This might be caused by the multi notebook, or custom
# animation layouting?
self._view.get_parent().resize_children()
def attach(self):
# Attach ourselves in the text view, and position just above the
# text window
win = self._view.get_window(Gtk.TextWindowType.TEXT)
alloc = self.get_allocation()
self._view.set_border_window_size(Gtk.TextWindowType.BOTTOM, max(alloc.height, 1))
self._view.add_child_in_window(self, Gtk.TextWindowType.BOTTOM, 0, 0)
win = self._view.get_window(Gtk.TextWindowType.BOTTOM)
self.show()
self.set_size_request(win.get_width(), -1)
def on_entry_focus_out(self, widget, evnt):
if self._entry.get_sensitive():
self.destroy()
def on_entry_key_press(self, widget, evnt):
state = evnt.state & Gtk.accelerator_get_default_mod_mask()
text = self._entry.get_text()
if evnt.keyval == Gdk.KEY_Escape:
if self._info_window:
if self._suspended:
self._suspended.resume()
if self._info_window:
self._info_window.destroy()
self._entry.set_sensitive(True)
elif self._accel_group:
self._accel_group = self._accel_group.parent
if not self._accel_group or not self._accel_group.parent:
self._entry.set_editable(True)
self._accel_group = None
self.prompt()
elif text:
self._entry.set_text("")
elif self._command_state:
self._command_state.clear()
self.prompt()
else:
self._view.grab_focus()
self.destroy()
return True
if state or self._accel_group:
# Check if it should be handled by the accel group
group = self._accel_group
if not self._accel_group:
group = commands.Commands().accelerator_group()
accel = group.activate(evnt.keyval, state)
if isinstance(accel, commands.accel_group.AccelGroup):
self._accel_group = accel
self._entry.set_text("")
self._entry.set_editable(False)
self.prompt()
return True
elif isinstance(accel, commands.accel_group.AccelCallback):
self._entry.set_editable(True)
self.run_command(lambda: accel.activate(self._command_state, self))
return True
if not self._entry.get_editable():
return True
for handler in self._handlers:
if (
(handler[0] == None or handler[0] == state)
and evnt.keyval == handler[1]
and handler[2](handler[3], state)
):
return True
if self._info_window and self._info_window.empty():
self._info_window.destroy()
self._history_prefix = None
return False
def on_history_move(self, direction, modifier):
pos = self._entry.get_position()
self._history.update(self._entry.get_text())
if self._history_prefix == None:
if len(self._entry.get_text()) == pos:
self._history_prefix = self._entry.get_chars(0, pos)
else:
self._history_prefix = ""
if self._history_prefix == None:
hist = ""
else:
hist = self._history_prefix
next = self._history.move(direction, hist)
if next != None:
self._entry.set_text(next)
self._entry.set_position(-1)
return True
def prompt(self, pr=""):
self._prompt = pr
if self._accel_group != None:
pr = "<i>%s</i>" % (saxutils.escape(self._accel_group.full_name()),)
if not pr:
pr = ""
else:
pr = " " + pr
self._prompt_label.set_markup("<b>>>></b>%s" % pr)
def make_info(self):
if self._info_window == None:
self._info_window = Info(self)
self._info_window.show()
self._info_window.connect("destroy", self.on_info_window_destroy)
def on_info_window_destroy(self, widget):
self._info_window = None
def info_show(self, text="", use_markup=False):
self.make_info()
self._info_window.add_lines(text, use_markup)
def info_status(self, text):
self.make_info()
self._info_window.status(text)
def info_add_action(self, stock, callback, data=None):
self.make_info()
return self._info_window.add_action(stock, callback, data)
def command_history_done(self):
self._history.add(self._entry.get_text())
self._history_prefix = None
self._entry.set_text("")
def on_wait_cancel(self):
if self._suspended:
self._suspended.resume()
if self._cancel_button:
self._cancel_button.destroy()
if self._info_window and self._info_window.empty():
self._info_window.destroy()
self._entry.grab_focus()
self._entry.set_sensitive(True)
def _show_wait_cancel(self):
self._cancel_button = self.info_add_action(Gtk.STOCK_STOP, self.on_wait_cancel)
self.info_status("<i>Waiting to finish...</i>")
self._wait_timeout = 0
return False
def _complete_word_match(self, match):
for i in (3, 2, 0):
if match.group(i) != None:
return [match.group(i), match.start(i), match.end(i)]
def on_suspend_resume(self):
if self._wait_timeout:
GLib.source_remove(self._wait_timeout)
self._wait_timeout = 0
else:
self._cancel_button.destroy()
self._cancel_button = None
self.info_status(None)
self._entry.set_sensitive(True)
self.command_history_done()
if self._entry.props.has_focus or (self._info_window and not self._info_window.empty()):
self._entry.grab_focus()
self.on_execute(None, 0)
def ellipsize(self, s, size):
if len(s) <= size:
return s
mid = (size - 4) / 2
return s[:mid] + "..." + s[-mid:]
def destroy(self):
self.hide()
Gtk.EventBox.destroy(self)
def run_command(self, cb):
self._suspended = None
try:
ret = cb()
except Exception as e:
self.command_history_done()
self._command_state.clear()
self.prompt()
# Show error in info
self.info_show('<b><span color="#f66">Error:</span></b> ' + saxutils.escape(str(e)), True)
if not isinstance(e, commands.exceptions.Execute):
self.info_show(self.format_trace(), False)
return None
mod = sys.modules["commander.commands.result"]
if ret == mod.Result.SUSPEND:
# Wait for it...
self._suspended = ret
ret.register(self.on_suspend_resume)
self._wait_timeout = GLib.timeout_add(500, self._show_wait_cancel)
self._entry.set_sensitive(False)
else:
self.command_history_done()
self.prompt("")
if ret == mod.Result.PROMPT:
self.prompt(ret.prompt)
elif (
(ret == None or ret == mod.HIDE)
and not self._prompt
and (not self._info_window or self._info_window.empty())
):
self._command_state.clear()
self._view.grab_focus()
self.destroy()
else:
self._entry.grab_focus()
return ret
def format_trace(self):
tp, val, tb = sys.exc_info()
origtb = tb
thisdir = os.path.dirname(__file__)
# Skip frames up until after the last entry.py...
while True:
filename = tb.tb_frame.f_code.co_filename
dname = os.path.dirname(filename)
if not dname.startswith(thisdir):
break
tb = tb.tb_next
msg = traceback.format_exception(tp, val, tb)
r = "".join(msg[0:-1])
# This is done to prevent cyclic references, see python
# documentation on sys.exc_info
del origtb
return r
def on_execute(self, dummy, modifier):
if self._info_window and not self._suspended:
self._info_window.destroy()
text = self._entry.get_text().strip()
words = list(self._re_complete.finditer(text))
wordsstr = []
for word in words:
spec = self._complete_word_match(word)
wordsstr.append(spec[0])
if not wordsstr and not self._command_state:
self._entry.set_text("")
return
self.run_command(
lambda: commands.Commands().execute(self._command_state, text, words, wordsstr, self, modifier)
)
return True
def on_complete(self, dummy, modifier):
# First split all the text in words
text = self._entry.get_text()
pos = self._entry.get_position()
words = list(self._re_complete.finditer(text))
wordsstr = []
for word in words:
spec = self._complete_word_match(word)
wordsstr.append(spec[0])
# Find out at which word the cursor actually is
# Examples:
# * hello world|
# * hello| world
# * |hello world
# * hello wor|ld
# * hello | world
# * "hello world|"
posidx = None
for idx in range(0, len(words)):
spec = self._complete_word_match(words[idx])
if words[idx].start(0) > pos:
# Empty space, new completion
wordsstr.insert(idx, "")
words.insert(idx, None)
posidx = idx
break
elif spec[2] == pos:
# At end of word, resume completion
posidx = idx
break
elif spec[1] <= pos and spec[2] > pos:
# In middle of word, do not complete
return True
if posidx == None:
wordsstr.append("")
words.append(None)
posidx = len(wordsstr) - 1
# First word completes a command, if not in any special 'mode'
# otherwise, relay completion to the command, or complete by advice
# from the 'mode' (prompt)
cmds = commands.Commands()
if not self._command_state and posidx == 0:
# Complete the first command
ret = commands.completion.command(words=wordsstr, idx=posidx)
else:
complete = None
realidx = posidx
if not self._command_state:
# Get the command first
cmd = commands.completion.single_command(wordsstr, 0)
realidx -= 1
ww = wordsstr[1:]
else:
cmd = self._command_state.top()
ww = wordsstr
if cmd:
complete = cmd.autocomplete_func()
if not complete:
return True
# 'complete' contains a dict with arg -> func to do the completion
# of the named argument the command (or stack item) expects
args, varargs = cmd.args()
# Remove system arguments
s = ["argstr", "args", "entry", "view"]
args = list(filter(lambda x: not x in s, args))
if realidx < len(args):
arg = args[realidx]
elif varargs:
arg = "*"
else:
return True
if not arg in complete:
return True
func = complete[arg]
try:
spec = utils.getargspec(func)
if not ww:
ww = [""]
kwargs = {"words": ww, "idx": realidx, "view": self._view}
if not spec.keywords:
for k in list(kwargs.keys()):
if not k in spec.args:
del kwargs[k]
ret = func(**kwargs)
except Exception as e:
# Can be number of arguments, or return values or simply buggy
# modules
print(e)
traceback.print_exc()
return True
if not ret or not ret[0]:
return True
res = ret[0]
completed = ret[1]
if len(ret) > 2:
after = ret[2]
else:
after = " "
# Replace the word
if words[posidx] == None:
# At end of everything, just append
spec = None
self._entry.insert_text(completed, self._entry.get_text_length())
self._entry.set_position(-1)
else:
spec = self._complete_word_match(words[posidx])
self._entry.delete_text(spec[1], spec[2])
self._entry.insert_text(completed, spec[1])
self._entry.set_position(spec[1] + len(completed))
if len(res) == 1:
# Full completion
lastpos = self._entry.get_position()
if not isinstance(res[0], commands.module.Module) or not res[0].commands():
if (
words[posidx]
and after == " "
and (words[posidx].group(2) != None or words[posidx].group(3) != None)
):
lastpos = lastpos + 1
self._entry.insert_text(after, lastpos)
self._entry.set_position(lastpos + 1)
elif completed == wordsstr[posidx] or not res[0].method:
self._entry.insert_text(".", lastpos)
self._entry.set_position(lastpos + 1)
if self._info_window:
self._info_window.destroy()
else:
# Show popup with completed items
if self._info_window:
self._info_window.clear()
ret = []
for x in res:
if isinstance(x, commands.method.Method):
ret.append("<b>" + saxutils.escape(x.name) + "</b> (<i>" + x.oneline_doc() + "</i>)")
else:
ret.append(str(x))
self.info_show("\n".join(ret), True)
return True
def on_draw(self, widget, ct):
win = widget.get_window(Gtk.TextWindowType.BOTTOM)
if not Gtk.cairo_should_draw_window(ct, win):
return False
Gtk.cairo_transform_to_window(ct, widget, win)
color = self.get_border_color()
width = win.get_width()
ct.set_source_rgba(color.red, color.green, color.blue, color.alpha)
ct.move_to(0, 0)
ct.line_to(width, 0)
ct.stroke()
return False
def on_destroy(self, widget):
self._view.set_border_window_size(Gtk.TextWindowType.BOTTOM, 0)
self._view.disconnect(self.view_style_updated_id)
self._view.disconnect(self.view_draw_id)
if self._info_window:
self._info_window.destroy()
self._history.save()
def __init__(self):
self.lcd.clear()
self.lcd.backlight(self.lcd.YELLOW)
self.info = Info()
class Display:
lcd = Adafruit_CharLCDPlate()
info = None
screen = []
screenIdx = 0
systemHalt = False
def __init__(self):
self.lcd.clear()
self.lcd.backlight(self.lcd.YELLOW)
self.info = Info()
def show(self):
if self.screenIdx == 0:
self.screen = self.info.screen0
elif self.screenIdx == 1:
self.screen = self.info.screen1
elif self.screenIdx == 2:
self.screen = self.info.screen2
elif self.screenIdx == 3:
self.screen = self.info.screen3
elif self.screenIdx == 4:
self.screen = self.info.screen4
elif self.screenIdx == 5:
self.screen = self.info.screen5
s = self.screen[0] + "\n" + self.screen[1]
self.lcd.clear()
self.lcd.message(s)
def update(self):
if self.systemHalt:
return
lock = self.info.isLocked()
# appropriately set backlight
if lock:
self.setBackgroundGreen()
self.info.fillData()
else:
self.setBackgroundRed()
self.info.noData()
self.show()
# if not self.systemHalt: self.show()
def moveUp(self):
if self.screenIdx == 0:
self.screenIdx = self.info.numPages
else:
self.screenIdx -= 1
def moveDown(self):
if self.screenIdx == self.info.numPages:
self.screenIdx = 0
else:
self.screenIdx += 1
def action(self):
if self.screenIdx == 0:
self.action0()
elif self.screenIdx == 1:
self.action1()
elif self.screenIdx == 2:
self.action2()
elif self.screenIdx == 3:
self.action3()
elif self.screenIdx == 4:
self.action4()
elif self.screenIdx == 5:
self.action5()
def action0(self):
""" action for page 1 """
pass
def action1(self):
""" action for page 2 """
pass
def action2(self):
""" action for page 3 """
pass
def action3(self):
""" reboot """
self.systemHalt = True
self.setBackgroundOff()
self.lcd.clear()
self.lcd.message("Rebooting ...")
subprocess.call("sync")
subprocess.call("reboot")
# exit(0)
def action4(self):
""" shutdown """
self.systemHalt = True
self.setBackgroundOff()
self.lcd.clear()
self.lcd.message("Wait till screen\nis off + 15secs!")
subprocess.call("sync")
subprocess.call(["shutdown", "-h", "now"])
# exit(0)
def action5(self):
self.exit()
def exit(self):
self.setLcdOff()
exit(0)
def setBackgroundGreen(self):
self.lcd.backlight(self.lcd.GREEN)
def setBackgroundOff(self):
self.lcd.backlight(self.lcd.TEAL)
def setBackgroundRed(self):
self.lcd.backlight(self.lcd.RED)
def setLcdOff(self):
self.lcd.clear()
self.lcd.backlight(self.lcd.OFF)
def setLcdOn(self):
self.lcd.clear()
self.lcd.backlight(self.lcd.ON)
class Entry(Gtk.Box):
__gtype_name__ = "CommanderEntry"
def _show(self):
self._reveal.set_reveal_child(True)
def _hide(self):
self._reveal.set_reveal_child(False)
def __init__(self, view):
super(Entry, self).__init__()
self._view = view
view.connect("destroy", self._on_view_destroyed)
self._history = History(os.path.join(GLib.get_user_config_dir(), 'gedit/commander/history'))
self._history_prefix = None
self._prompt_text = None
self._accel_group = None
self._wait_timeout = 0
self._cancel_button = None
self._info = None
self._info_revealer = None
self._suspended = None
self._handlers = [
[0, Gdk.KEY_Up, self._on_history_move, -1],
[0, Gdk.KEY_Down, self._on_history_move, 1],
[None, Gdk.KEY_Return, self._on_execute, None],
[None, Gdk.KEY_KP_Enter, self._on_execute, None],
[0, Gdk.KEY_Tab, self._on_complete, None],
[0, Gdk.KEY_ISO_Left_Tab, self._on_complete, None]
]
self._re_complete = re.compile('("((?:\\\\"|[^"])*)"?|\'((?:\\\\\'|[^\'])*)\'?|[^\s]+)')
self._command_state = commands.Commands.State()
self.connect('destroy', self._on_destroy)
self._build_ui()
self._setup_keybindings()
self._attach()
def view(self):
return self._view
def _setup_keybindings(self):
css = Gtk.CssProvider()
css.load_from_data(bytes("""
@binding-set terminal-like-bindings {
unbind "<Control>A";
bind "<Control>W" { "delete-from-cursor" (word-ends, -1) };
bind "<Control>A" { "move-cursor" (buffer-ends, -1, 0) };
bind "<Control>U" { "delete-from-cursor" (display-line-ends, -1) };
bind "<Control>K" { "delete-from-cursor" (display-line-ends, 1) };
bind "<Control>E" { "move-cursor" (buffer-ends, 1, 0) };
bind "Escape" { "delete-from-cursor" (display-lines, 1) };
}
GtkEntry#gedit-commander-entry {
gtk-key-bindings: terminal-like-bindings;
background-image: none;
box-shadow: 0 0;
transition: none;
border: 0;
}
""", 'utf-8'))
self._entry.get_style_context().add_provider(css, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
def _find_overlay(self, view):
parent = view.get_parent()
while not isinstance(parent, Gtk.Overlay):
parent = parent.get_parent()
return parent
def _build_ui(self):
self.set_orientation(Gtk.Orientation.VERTICAL)
self._overlay = self._find_overlay(self._view)
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=6)
hbox.show()
self.pack_end(hbox, False, False, 0)
self._info_revealer = Gtk.Revealer()
self._info_revealer.set_transition_type(Gtk.RevealerTransitionType.SLIDE_UP)
self._info_revealer.set_transition_duration(150)
self.pack_start(self._info_revealer, False, False, 0)
self._info_revealer.connect('notify::child-revealed', self._on_info_revealer_child_revealed)
self._prompt_label = Gtk.Label(label='<b>>>></b>', use_markup=True)
self._prompt_label.set_margin_top(3)
self._prompt_label.set_margin_bottom(3)
self._prompt_label.set_margin_start(3)
self._prompt_label.show()
hbox.add(self._prompt_label)
self._entry = Gtk.Entry()
self._entry.set_has_frame(False)
self._entry.set_name('gedit-commander-entry')
self._entry.set_hexpand(True)
self._entry.set_margin_top(3)
self._entry.set_margin_bottom(3)
self._entry.set_margin_end(3)
self._entry.connect('key-press-event', self._on_entry_key_press)
self._entry.show()
hbox.add(self._entry)
self._copy_style_from_view()
self._view_style_updated_id = self._view.connect('style-updated', self._on_view_style_updated)
def _on_view_destroyed (self, widget, user_data=None):
self._view.disconnect(self._view_style_updated_id)
self._view_style_updated_id = None
def _on_view_style_updated(self, widget):
self._copy_style_from_view()
@property
def _border_color(self):
style = self._view.get_buffer().get_style_scheme().get_style('right-margin')
if not style is None and style.props.foreground_set:
color = Gdk.RGBA()
color.parse(style.props.foreground)
else:
color = self._get_background_color(Gtk.StateFlags.NORMAL, 'bottom').copy()
color.red = 1 - color.red
color.green = 1 - color.green
color.blue = 1 - color.blue
color.alpha = 0.3
return color
def _get_background_color(self, state, cls=None):
context = self._view.get_style_context()
context.save()
if not cls is None:
context.add_class(cls)
ret = context.get_background_color(state)
context.restore()
return ret
def _get_foreground_color(self, state, cls=None):
context = self._view.get_style_context()
context.save()
if not cls is None:
context.add_class(cls)
ret = context.get_color(state)
context.restore()
return ret
def _get_font(self):
context = self._view.get_style_context()
return context.get_font(Gtk.StateFlags.NORMAL)
def _styled_widgets(self):
widgets = [self, self._entry, self._prompt_label]
if not self._info is None:
widgets.append(self._info)
widgets.append(self._info.text_view)
return widgets
def _modify_bg(self, col, widget):
if self._info is None or (self._info.text_view != widget and self._info != widget):
return col
d = 0.1
h, l, s = colorsys.rgb_to_hls(col.red, col.green, col.blue)
if l < 0.5:
factor = 1 + d
else:
factor = 1 - d
l = max(0, min(1, l * factor))
s = max(0, min(1, s * factor))
r, g, b = colorsys.hls_to_rgb(h, l, s)
return Gdk.RGBA(r, g, b, col.alpha)
def _copy_style_from_view(self, widgets=None):
font = self._get_font()
fg = self._get_foreground_color(Gtk.StateFlags.NORMAL, 'bottom')
bg = self._get_background_color(Gtk.StateFlags.NORMAL, 'bottom')
fgsel = self._get_foreground_color(Gtk.StateFlags.SELECTED)
bgsel = self._get_background_color(Gtk.StateFlags.SELECTED)
cursor = self._view.style_get_property('cursor-color')
if not cursor is None:
cursor = Gdk.RGBA.from_color(cursor)
secondary_cursor = self._view.style_get_property('secondary-cursor-color')
if not secondary_cursor is None:
secondary_cursor = Gdk.RGBA.from_color(secondary_cursor)
if widgets is None:
widgets = self._styled_widgets()
for widget in widgets:
widget.override_color(Gtk.StateFlags.NORMAL, fg)
widget.override_background_color(Gtk.StateFlags.NORMAL, self._modify_bg(bg, widget))
widget.override_color(Gtk.StateFlags.SELECTED, fgsel)
widget.override_background_color(Gtk.StateFlags.SELECTED, self._modify_bg(bgsel, widget))
widget.override_font(font)
widget.override_cursor(cursor, secondary_cursor)
def _attach(self):
reveal = Gtk.Revealer()
reveal.add(self)
self.show()
reveal.set_transition_type(Gtk.RevealerTransitionType.SLIDE_UP)
reveal.set_transition_duration(200)
reveal.set_valign(Gtk.Align.END)
reveal.set_halign(Gtk.Align.FILL)
self._overlay.add_overlay(reveal)
reveal.show()
reveal.set_reveal_child(True)
self._reveal = reveal
self._entry.grab_focus()
def grab_focus(self):
self._entry.grab_focus()
def _on_entry_key_press(self, widget, evnt):
state = evnt.state & Gtk.accelerator_get_default_mod_mask()
text = self._entry.get_text()
if evnt.keyval == Gdk.KEY_Escape:
if not self._info is None:
if not self._suspended is None:
self._suspended.resume()
if not self._info is None:
self._info_revealer.set_reveal_child(False)
self._entry.set_sensitive(True)
elif self._accel_group:
self._accel_group = self._accel_group.parent
if not self._accel_group or not self._accel_group.parent:
self._entry.set_editable(True)
self._accel_group = None
self._prompt()
elif text:
self._entry.set_text('')
elif self._command_state:
self._command_state.clear()
self._prompt()
else:
self._view.grab_focus()
self._reveal.set_reveal_child(False)
return True
if state or self._accel_group:
# Check if it should be handled by the accel group
group = self._accel_group
if not self._accel_group:
group = commands.Commands().accelerator_group()
accel = group.activate(evnt.keyval, state)
if isinstance(accel, commands.accel_group.AccelGroup):
self._accel_group = accel
self._entry.set_text('')
self._entry.set_editable(False)
self._prompt()
return True
elif isinstance(accel, commands.accel_group.AccelCallback):
self._entry.set_editable(True)
self._run_command(lambda: accel.activate(self._command_state, self))
return True
if not self._entry.get_editable():
return True
for handler in self._handlers:
if (handler[0] == None or handler[0] == state) and evnt.keyval == handler[1] and handler[2](handler[3], state):
return True
if not self._info is None and self._info.is_empty:
self._info_revealer.set_reveal_child(False)
self._history_prefix = None
return False
def _on_history_move(self, direction, modifier):
pos = self._entry.get_position()
self._history.update(self._entry.get_text())
if self._history_prefix == None:
if len(self._entry.get_text()) == pos:
self._history_prefix = self._entry.get_chars(0, pos)
else:
self._history_prefix = ''
if self._history_prefix == None:
hist = ''
else:
hist = self._history_prefix
next = self._history.move(direction, hist)
if next != None:
self._entry.set_text(next)
self._entry.set_position(-1)
return True
def _prompt(self, pr=''):
self._prompt_text = pr
if self._accel_group != None:
pr = '<i>%s</i>' % (saxutils.escape(self._accel_group.full_name()),)
if not pr:
pr = ''
else:
pr = ' ' + pr
self._prompt_label.set_markup('<b>>>></b>%s' % pr)
def _make_info(self):
if self._info is None:
self._info = Info()
self._copy_style_from_view([self._info, self._info.text_view])
self._info_revealer.add(self._info)
self._info.show()
self._info_revealer.show()
self._info_revealer.set_reveal_child(True)
self._info.connect('destroy', self._on_info_destroy)
def _on_info_revealer_child_revealed(self, widget, pspec):
if not self._info_revealer.get_child_revealed():
self._info.destroy()
self._info_revealer.hide()
def _on_info_destroy(self, widget):
self._info = None
def info_show(self, text='', use_markup=False):
self._make_info()
self._info.add_lines(text, use_markup)
def info_status(self, text):
self._make_info()
self._info.status(text)
def _info_add_action(self, stock, callback, data=None):
self._make_info()
return self._info.add_action(stock, callback, data)
def _command_history_done(self):
self._history.add(self._entry.get_text())
self._history_prefix = None
self._entry.set_text('')
def _on_wait_cancel(self):
self._on_execute(None, 0)
def _show_wait_cancel(self):
self._cancel_button = self._info_add_action('process-stop-symbolic', self._on_wait_cancel)
self.info_status('<i>Waiting to finish\u2026</i>')
self._wait_timeout = 0
return False
def _complete_word_match(self, match):
for i in (3, 2, 0):
if match.group(i) != None:
return [match.group(i), match.start(i), match.end(i)]
def _on_suspend_resume(self):
if self._wait_timeout:
GLib.source_remove(self._wait_timeout)
self._wait_timeout = 0
else:
if not self._cancel_button is None:
self._cancel_button.destroy()
self._cancel_button = None
self.info_status(None)
self._entry.set_sensitive(True)
self._command_history_done()
if self._entry.props.has_focus or (not self._info is None and not self._info.is_empty):
self._entry.grab_focus()
def _run_command(self, cb):
self._suspended = None
try:
ret = cb()
except Exception as e:
sys.stderr.write(self._format_trace() + '\n')
self._command_history_done()
self._command_state.clear()
self._prompt()
# Show error in info
self.info_show('<b><span color="#f66">Error:</span></b> ' + saxutils.escape(str(e)), True)
if not isinstance(e, commands.exceptions.Execute):
self.info_show(self._format_trace(), False)
return None
mod = sys.modules['commander.commands.result']
if ret == mod.Result.SUSPEND:
# Wait for it...
self._suspended = ret
ret.register(self._on_suspend_resume)
self._wait_timeout = GLib.timeout_add(500, self._show_wait_cancel)
self._entry.set_sensitive(False)
else:
self._command_history_done()
self._prompt('')
if ret == mod.Result.PROMPT:
self._prompt(ret.prompt)
elif (ret == None or ret == mod.HIDE) and not self._prompt_text and (self._info is None or self._info.is_empty):
self._command_state.clear()
self._view.grab_focus()
self._reveal.set_reveal_child(False)
else:
self._entry.grab_focus()
return ret
def _format_trace(self):
tp, val, tb = sys.exc_info()
origtb = tb
thisdir = os.path.dirname(__file__)
# Skip frames up until after the last entry.py...
while not tb is None:
filename = tb.tb_frame.f_code.co_filename
dname = os.path.dirname(filename)
if not dname.startswith(thisdir):
break
tb = tb.tb_next
msg = traceback.format_exception(tp, val, tb)
r = ''.join(msg[0:-1])
# This is done to prevent cyclic references, see python
# documentation on sys.exc_info
del origtb
return r
def _on_execute(self, dummy, modifier):
if not self._info is None and not self._suspended:
self._info_revealer.set_reveal_child(False)
text = self._entry.get_text().strip()
words = list(self._re_complete.finditer(text))
wordsstr = []
for word in words:
spec = self._complete_word_match(word)
wordsstr.append(spec[0])
if not wordsstr and not self._command_state:
self._entry.set_text('')
return
self._run_command(lambda: commands.Commands().execute(self._command_state, text, words, wordsstr, self, modifier))
return True
def _on_complete(self, dummy, modifier):
# First split all the text in words
text = self._entry.get_text()
pos = self._entry.get_position()
words = list(self._re_complete.finditer(text))
wordsstr = []
for word in words:
spec = self._complete_word_match(word)
wordsstr.append(spec[0])
# Find out at which word the cursor actually is
# Examples:
# * hello world|
# * hello| world
# * |hello world
# * hello wor|ld
# * hello | world
# * "hello world|"
posidx = None
for idx in range(0, len(words)):
spec = self._complete_word_match(words[idx])
if words[idx].start(0) > pos:
# Empty space, new completion
wordsstr.insert(idx, '')
words.insert(idx, None)
posidx = idx
break
elif spec[2] == pos:
# At end of word, resume completion
posidx = idx
break
elif spec[1] <= pos and spec[2] > pos:
# In middle of word, do not complete
return True
if posidx == None:
wordsstr.append('')
words.append(None)
posidx = len(wordsstr) - 1
# First word completes a command, if not in any special 'mode'
# otherwise, relay completion to the command, or complete by advice
# from the 'mode' (prompt)
cmds = commands.Commands()
if not self._command_state and posidx == 0:
# Complete the first command
ret = commands.completion.command(words=wordsstr, idx=posidx)
else:
complete = None
realidx = posidx
if not self._command_state:
# Get the command first
cmd = commands.completion.single_command(wordsstr, 0)
realidx -= 1
ww = wordsstr[1:]
else:
cmd = self._command_state.top()
ww = wordsstr
if cmd:
complete = cmd.autocomplete_func()
if not complete:
return True
# 'complete' contains a dict with arg -> func to do the completion
# of the named argument the command (or stack item) expects
args, varargs = cmd.args()
# Remove system arguments
s = ['argstr', 'args', 'entry', 'view']
args = list(filter(lambda x: not x in s, args))
if realidx < len(args):
arg = args[realidx]
elif varargs:
arg = '*'
else:
return True
if not arg in complete:
return True
func = complete[arg]
try:
spec = utils.getargspec(func)
if not ww:
ww = ['']
kwargs = {
'words': ww,
'idx': realidx,
'view': self._view
}
if not spec.keywords:
for k in list(kwargs.keys()):
if not k in spec.args:
del kwargs[k]
ret = func(**kwargs)
except Exception as e:
# Can be number of arguments, or return values or simply buggy
# modules
print(e)
traceback.print_exc()
return True
if not ret or not ret[0]:
return True
res = ret[0]
completed = ret[1]
if len(ret) > 2:
after = ret[2]
else:
after = ' '
# Replace the word
if words[posidx] == None:
# At end of everything, just append
spec = None
self._entry.insert_text(completed, self._entry.get_text_length())
self._entry.set_position(-1)
else:
spec = self._complete_word_match(words[posidx])
self._entry.delete_text(spec[1], spec[2])
self._entry.insert_text(completed, spec[1])
self._entry.set_position(spec[1] + len(completed))
if len(res) == 1:
# Full completion
lastpos = self._entry.get_position()
if not isinstance(res[0], commands.module.Module) or not res[0].commands():
if words[posidx] and after == ' ' and (words[posidx].group(2) != None or words[posidx].group(3) != None):
lastpos = lastpos + 1
self._entry.insert_text(after, lastpos)
self._entry.set_position(lastpos + 1)
elif completed == wordsstr[posidx] or not res[0].method:
self._entry.insert_text('.', lastpos)
self._entry.set_position(lastpos + 1)
if not self._info is None:
self._info_revealer.set_reveal_child(False)
else:
# Show popup with completed items
if not self._info is None:
self._info.clear()
ret = []
for x in res:
if isinstance(x, commands.method.Method):
ret.append('<b>' + saxutils.escape(x.name) + '</b> (<i>' + x.oneline_doc() + '</i>)')
else:
ret.append(str(x))
self.info_show("\n".join(ret), True)
return True
def do_draw(self, ctx):
ret = Gtk.Box.do_draw(self, ctx)
col = self._border_color
ctx.set_line_width(1)
ctx.set_source_rgba(col.red, col.green, col.blue, col.alpha)
w = self.get_allocated_width()
ctx.move_to(0, 0.5)
ctx.line_to(w, 0.5)
ctx.stroke()
if not self._info is None:
alloc = self._info_revealer.get_allocation()
y = alloc.y + alloc.height + 0.5
if y >= 3:
ctx.move_to(0, y)
ctx.line_to(w, y)
ctx.stroke()
return ret
def _on_destroy(self, widget):
# Note we do this not as an override because somehow something
# goes wrong when finalizing in that case, maybe self is NULL
# or something like that, and then gets some new empty instance?
if self._view_style_updated_id:
self._view.disconnect(self._view_style_updated_id)
self._history.save()
self._view = None
self._view_style_updated_id = None
def make_info(self):
if self._info_window == None:
self._info_window = Info(self)
self._info_window.show()
self._info_window.connect('destroy', self.on_info_window_destroy)
class Entry(gtk.EventBox):
def __init__(self, view):
gtk.EventBox.__init__(self)
self._view = view
hbox = gtk.HBox(False, 3)
hbox.show()
hbox.set_border_width(3)
self._entry = gtk.Entry()
self._entry.modify_font(self._view.style.font_desc)
self._entry.set_has_frame(False)
self._entry.set_name('command-bar')
self._entry.modify_text(gtk.STATE_NORMAL, self._view.style.text[gtk.STATE_NORMAL])
self._entry.set_app_paintable(True)
self._entry.connect('realize', self.on_realize)
self._entry.connect('expose-event', self.on_entry_expose)
self._entry.show()
self._prompt_label = gtk.Label('<b>>>></b>')
self._prompt_label.set_use_markup(True)
self._prompt_label.modify_font(self._view.style.font_desc)
self._prompt_label.show()
self._prompt_label.modify_fg(gtk.STATE_NORMAL, self._view.style.text[gtk.STATE_NORMAL])
self.modify_bg(gtk.STATE_NORMAL, self.background_gdk())
self._entry.modify_base(gtk.STATE_NORMAL, self.background_gdk())
self._entry.connect('focus-out-event', self.on_entry_focus_out)
self._entry.connect('key-press-event', self.on_entry_key_press)
self.connect_after('size-allocate', self.on_size_allocate)
self.connect_after('expose-event', self.on_expose)
self.connect_after('realize', self.on_realize)
self._history = History(os.path.expanduser('~/.gnome2/gedit/commander/history'))
self._prompt = None
hbox.pack_start(self._prompt_label, False, False, 0)
hbox.pack_start(self._entry, True, True, 0)
self.add(hbox)
self.attach()
self._entry.grab_focus()
self._wait_timeout = 0
self._info_window = None
self.connect('destroy', self.on_destroy)
self._history_prefix = None
self._suspended = None
self._handlers = [
[0, gtk.keysyms.Up, self.on_history_move, -1],
[0, gtk.keysyms.Down, self.on_history_move, 1],
[None, gtk.keysyms.Return, self.on_execute, None],
[None, gtk.keysyms.KP_Enter, self.on_execute, None],
[0, gtk.keysyms.Tab, self.on_complete, None],
[0, gtk.keysyms.ISO_Left_Tab, self.on_complete, None]
]
self._re_complete = re.compile('("((?:\\\\"|[^"])*)"?|\'((?:\\\\\'|[^\'])*)\'?|[^\s]+)')
self._command_state = commands.Commands.State()
def view(self):
return self._view
def on_realize(self, widget):
widget.window.set_back_pixmap(None, False)
def on_entry_expose(self, widget, evnt):
ct = evnt.window.cairo_create()
ct.rectangle(evnt.area.x, evnt.area.y, evnt.area.width, evnt.area.height)
bg = self.background_color()
ct.set_source_rgb(bg[0], bg[1], bg[1])
ct.fill()
return False
def on_expose(self, widget, evnt):
ct = evnt.window.cairo_create()
color = self.background_color()
ct.rectangle(evnt.area.x, evnt.area.y, evnt.area.width, evnt.area.height)
ct.clip()
# Draw separator line
ct.move_to(0, 0)
ct.set_line_width(1)
ct.line_to(self.allocation.width, 0)
ct.set_source_rgb(1 - color[0], 1 - color[1], 1 - color[2])
ct.stroke()
return False
def on_size_allocate(self, widget, alloc):
vwwnd = self._view.get_window(gtk.TEXT_WINDOW_BOTTOM).get_parent()
size = vwwnd.get_size()
position = vwwnd.get_position()
self._view.set_border_window_size(gtk.TEXT_WINDOW_BOTTOM, alloc.height)
def attach(self):
# Attach ourselves in the text view, and position just above the
# text window
self._view.set_border_window_size(gtk.TEXT_WINDOW_BOTTOM, 1)
alloc = self._view.allocation
self.show()
self._view.add_child_in_window(self, gtk.TEXT_WINDOW_BOTTOM, 0, 0)
self.set_size_request(alloc.width, -1)
def background_gdk(self):
bg = self.background_color()
bg = map(lambda x: int(x * 65535), bg)
return gtk.gdk.Color(bg[0], bg[1], bg[2])
def background_color(self):
bg = self._view.get_style().base[self._view.state]
return [bg.red / 65535.0 * 1.1, bg.green / 65535.0 * 1.1, bg.blue / 65535.0 * 0.9, 0.8]
def on_entry_focus_out(self, widget, evnt):
if self._entry.flags() & gtk.SENSITIVE:
self.destroy()
def on_entry_key_press(self, widget, evnt):
state = evnt.state & gtk.accelerator_get_default_mod_mask()
text = self._entry.get_text()
if evnt.keyval == gtk.keysyms.Escape and self._info_window:
if self._suspended:
self._suspended.resume()
if self._info_window:
self._info_window.destroy()
self._entry.set_sensitive(True)
return True
if evnt.keyval == gtk.keysyms.Escape:
if text:
self._entry.set_text('')
elif self._command_state:
self._command_state.clear()
self.prompt()
else:
self._view.grab_focus()
self.destroy()
return True
for handler in self._handlers:
if (handler[0] == None or handler[0] == state) and evnt.keyval == handler[1] and handler[2](handler[3], state):
return True
if self._info_window and self._info_window.empty():
self._info_window.destroy()
self._history_prefix = None
return False
def on_history_move(self, direction, modifier):
pos = self._entry.get_position()
self._history.update(self._entry.get_text())
if self._history_prefix == None:
if len(self._entry.get_text()) == pos:
self._history_prefix = self._entry.get_chars(0, pos)
else:
self._history_prefix = ''
if self._history_prefix == None:
hist = ''
else:
hist = self._history_prefix
next = self._history.move(direction, hist)
if next != None:
self._entry.set_text(next)
self._entry.set_position(-1)
return True
def prompt(self, pr=''):
self._prompt = pr
if not pr:
pr = ''
else:
pr = ' ' + pr
self._prompt_label.set_markup('<b>>>></b>%s' % pr)
def make_info(self):
if self._info_window == None:
self._info_window = Info(self)
self._info_window.show()
self._info_window.connect('destroy', self.on_info_window_destroy)
def on_info_window_destroy(self, widget):
self._info_window = None
def info_show(self, text='', use_markup=False):
self.make_info()
self._info_window.add_lines(text, use_markup)
def info_status(self, text):
self.make_info()
self._info_window.status(text)
def info_add_action(self, stock, callback, data=None):
self.make_info()
return self._info_window.add_action(stock, callback, data)
def command_history_done(self):
self._history.update(self._entry.get_text())
self._history.add()
self._history_prefix = None
self._entry.set_text('')
def on_wait_cancel(self):
if self._suspended:
self._suspended.resume()
if self._cancel_button:
self._cancel_button.destroy()
if self._info_window and self._info_window.empty():
self._info_window.destroy()
self._entry.grab_focus()
self._entry.set_sensitive(True)
def _show_wait_cancel(self):
self._cancel_button = self.info_add_action(gtk.STOCK_STOP, self.on_wait_cancel)
self.info_status('<i>Waiting to finish...</i>')
self._wait_timeout = 0
return False
def _complete_word_match(self, match):
for i in (3, 2, 0):
if match.group(i) != None:
return [match.group(i), match.start(i), match.end(i)]
def on_suspend_resume(self):
if self._wait_timeout:
glib.source_remove(self._wait_timeout)
self._wait_timeout = 0
else:
self._cancel_button.destroy()
self._cancel_button = None
self.info_status(None)
self._entry.set_sensitive(True)
self.command_history_done()
if self._entry.props.has_focus or (self._info_window and not self._info_window.empty()):
self._entry.grab_focus()
self.on_execute(None, 0)
def ellipsize(self, s, size):
if len(s) <= size:
return s
mid = (size - 4) / 2
return s[:mid] + '...' + s[-mid:]
def destroy(self):
self.hide()
gtk.EventBox.destroy(self)
def on_execute(self, dummy, modifier):
if self._info_window and not self._suspended:
self._info_window.destroy()
text = self._entry.get_text().strip()
words = list(self._re_complete.finditer(text))
wordsstr = []
for word in words:
spec = self._complete_word_match(word)
wordsstr.append(spec[0])
if not wordsstr and not self._command_state:
self._entry.set_text('')
return
self._suspended = None
try:
ret = commands.Commands().execute(self._command_state, text, words, wordsstr, self, modifier)
except Exception, e:
self.command_history_done()
self._command_state.clear()
self.prompt()
# Show error in info
self.info_show('<b><span color="#f66">Error:</span></b> ' + saxutils.escape(str(e)), True)
if not isinstance(e, commands.exceptions.Execute):
self.info_show(traceback.format_exc(), False)
return True
if ret == commands.result.Result.SUSPEND:
# Wait for it...
self._suspended = ret
ret.register(self.on_suspend_resume)
self._wait_timeout = glib.timeout_add(500, self._show_wait_cancel)
self._entry.set_sensitive(False)
else:
self.command_history_done()
self.prompt('')
if ret == commands.result.Result.PROMPT:
self.prompt(ret.prompt)
elif (ret == None or ret == commands.result.HIDE) and not self._prompt and (not self._info_window or self._info_window.empty()):
self._command_state.clear()
self._view.grab_focus()
self.destroy()
else:
self._entry.grab_focus()
return True
def info_clicked(self):
info_window = Info()
info_window.exec_()
searching = False
#-------------------------------------------------------------------------------
# INITIALISE GAME
#-------------------------------------------------------------------------------
pygame.mixer.pre_init(44100, -16, 16, 2048)
pygame.init()
pygame.display.set_icon(pygame.image.load(os.path.join("centipede", "icon.png")))
window = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT + DISPLAY_PANEL))
pygame.display.set_caption("Centipede (1.0.1)")
pygame.mouse.set_visible(False)
gameOver = Info(130, 280, pygame.image.load(os.path.join("centipede", "backtowork.png")))
# font for the display panel
fontSmaller = pygame.font.SysFont('arial black', 20, False, False)
gameTimer = pygame.time.Clock()
gamePaused = False
gamePlaying = False
gameOverDisplayTimer = 0
HIGH_SCORE = 0
try:
hiScoreFile = open('hiscore', 'r')
HIGH_SCORE = int(hiScoreFile.readline())
def __init__(self, preferences, market):
QMainWindow.__init__(self)
self.preferences = preferences
self.market = market
# set up main window
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# improve ui on mac
if utilities.platform_is_mac():
self.adjust_for_mac()
# connect market signals to our logic
self.market.signal_log.connect(self.slot_log)
self.market.signal_wallet.connect(self.display_wallet)
self.market.signal_orderlag.connect(self.display_orderlag)
self.market.signal_userorder.connect(self.display_userorder)
self.market.signal_ticker.connect(self.update_ticker)
# connect ui signals to our logic
self.ui.pushButtonGo.released.connect(self.execute_trade)
self.ui.tableAsk.clicked.connect(self.slot_update_price_from_asks)
self.ui.tableBid.clicked.connect(self.slot_update_price_from_bids)
self.ui.pushButtonCancel.released.connect(self.cancel_order)
self.ui.textBrowserStatus.anchorClicked.connect(self.order_selected)
self.ui.pushButtonSize.released.connect(self.recalculate_size)
self.ui.pushButtonPrice.released.connect(self.update_price_best)
self.ui.pushButtonTotal.released.connect(self.recalculate_total)
self.ui.actionPreferences_2.triggered.connect(self.show_preferences)
# associate log channels with their check boxes
self.logchannels = [
[self.ui.checkBoxLogTicker, "tick"],
[self.ui.checkBoxLogTrade, "TRADE"],
[self.ui.checkBoxLogDepth, "depth"],
]
# set correct resizing for the bid and ask tables
self.ui.tableAsk.horizontalHeader().setResizeMode(QHeaderView.Stretch)
self.ui.tableBid.horizontalHeader().setResizeMode(QHeaderView.Stretch)
# set up info table
self.info = Info(self, self.preferences, self.ui.tableInfo.clicked)
self.ui.tableInfo.setModel(self.info)
self.ui.tableInfo.horizontalHeader().setResizeMode(QHeaderView.Stretch)
# connect to signals from info table
self.info.signal_base_balance_clicked.connect(self.set_trade_size_from_wallet)
self.info.signal_quote_balance_clicked.connect(self.set_trade_total_from_wallet)
# initializes dynamic ui elements
self.init()
# activate market
self.market.start()
# show main window
self.adjustSize()
self.show()
self.raise_()
def __init__(self, parent, title):
wx.Frame.__init__(self, parent, title=title)
# Splitters and Panels
self.controls_map_splitter = wx.SplitterWindow(self)
self.controls_map_splitter.SetMinimumPaneSize(300)
controls_panel = wx.Panel(self.controls_map_splitter)
map_panel = wx.Panel(self.controls_map_splitter)
self.graphs_messages_splitter = wx.SplitterWindow(controls_panel)
self.graphs_messages_splitter.SetMinimumPaneSize(50)
graphs_panel = wx.Panel(self.graphs_messages_splitter)
messages_panel = wx.Panel(self.graphs_messages_splitter)
# World graphic
self._graphics = worldmap.WorldMap(map_panel)
self.graphics_sizer = wx.BoxSizer(wx.VERTICAL)
self.graphics_sizer.Add(self._graphics, 1, wx.EXPAND)
map_panel.SetSizerAndFit(self.graphics_sizer)
# Controls panel
self.controls = Controls(controls_panel, (300, 250), self)
# Info panel
self.info = Info(controls_panel, (300, 250))
# Graph canvas
self.graphs = graphs.Graphs(graphs_panel, (300, 300))
# Messages panel
self.messages = Messages(messages_panel, (600, 200))
self.interface_sizer = wx.BoxSizer(wx.VERTICAL)
self.controls_info_sizer = wx.BoxSizer(wx.HORIZONTAL)
self.controls_info_sizer.Add(self.info, 0, wx.EXPAND)
self.controls_info_sizer.Add((20, -1), proportion=0) # Padding
self.controls_info_sizer.Add(self.controls, 1, wx.EXPAND)
self.messages_sizer = wx.BoxSizer(wx.VERTICAL)
self.messages_sizer.Add(self.messages, 1, wx.EXPAND)
messages_panel.SetSizerAndFit(self.messages_sizer)
self.graphs_sizer = wx.BoxSizer(wx.VERTICAL)
self.graphs_sizer.Add(self.graphs, 1, wx.EXPAND)
graphs_panel.SetSizerAndFit(self.graphs_sizer)
self.interface_sizer.Add(self.controls_info_sizer, 0, wx.EXPAND)
self.interface_sizer.Add(self.graphs_messages_splitter, 1, wx.EXPAND)
controls_panel.SetSizerAndFit(self.interface_sizer)
self.graphs_messages_splitter.SplitHorizontally(
messages_panel,
graphs_panel
)
self.controls_map_splitter.SplitVertically(controls_panel, map_panel)
# Set up event handler for any worker thread results
EVT_RESULT(self, self.OnResult)
EVT_STOP(self, self.OnStop)
# Set up close event so timer is properly stopped
wx.EVT_CLOSE(self, self.OnClose)
self.reset_gui()
self.Show()
class Window(wx.Frame):
def __init__(self, parent, title):
wx.Frame.__init__(self, parent, title=title)
# Splitters and Panels
self.controls_map_splitter = wx.SplitterWindow(self)
self.controls_map_splitter.SetMinimumPaneSize(300)
controls_panel = wx.Panel(self.controls_map_splitter)
map_panel = wx.Panel(self.controls_map_splitter)
self.graphs_messages_splitter = wx.SplitterWindow(controls_panel)
self.graphs_messages_splitter.SetMinimumPaneSize(50)
graphs_panel = wx.Panel(self.graphs_messages_splitter)
messages_panel = wx.Panel(self.graphs_messages_splitter)
# World graphic
self._graphics = worldmap.WorldMap(map_panel)
self.graphics_sizer = wx.BoxSizer(wx.VERTICAL)
self.graphics_sizer.Add(self._graphics, 1, wx.EXPAND)
map_panel.SetSizerAndFit(self.graphics_sizer)
# Controls panel
self.controls = Controls(controls_panel, (300, 250), self)
# Info panel
self.info = Info(controls_panel, (300, 250))
# Graph canvas
self.graphs = graphs.Graphs(graphs_panel, (300, 300))
# Messages panel
self.messages = Messages(messages_panel, (600, 200))
self.interface_sizer = wx.BoxSizer(wx.VERTICAL)
self.controls_info_sizer = wx.BoxSizer(wx.HORIZONTAL)
self.controls_info_sizer.Add(self.info, 0, wx.EXPAND)
self.controls_info_sizer.Add((20, -1), proportion=0) # Padding
self.controls_info_sizer.Add(self.controls, 1, wx.EXPAND)
self.messages_sizer = wx.BoxSizer(wx.VERTICAL)
self.messages_sizer.Add(self.messages, 1, wx.EXPAND)
messages_panel.SetSizerAndFit(self.messages_sizer)
self.graphs_sizer = wx.BoxSizer(wx.VERTICAL)
self.graphs_sizer.Add(self.graphs, 1, wx.EXPAND)
graphs_panel.SetSizerAndFit(self.graphs_sizer)
self.interface_sizer.Add(self.controls_info_sizer, 0, wx.EXPAND)
self.interface_sizer.Add(self.graphs_messages_splitter, 1, wx.EXPAND)
controls_panel.SetSizerAndFit(self.interface_sizer)
self.graphs_messages_splitter.SplitHorizontally(
messages_panel,
graphs_panel
)
self.controls_map_splitter.SplitVertically(controls_panel, map_panel)
# Set up event handler for any worker thread results
EVT_RESULT(self, self.OnResult)
EVT_STOP(self, self.OnStop)
# Set up close event so timer is properly stopped
wx.EVT_CLOSE(self, self.OnClose)
self.reset_gui()
self.Show()
def reset_gui(self):
self.controls.reset_buttons()
self.messages.clear()
self.graphs.reset_data()
# Event Methods
def OnStart(self, event):
self.controls.set_buttons_ready()
self._simulation = simulation.Simulation()
self._simulation.setup_config(self.controls.get_config_filename())
self.simulation_info = self._simulation.initialize()
if not self.simulation_info.interface_config.print_messages:
self.messages.deactivate()
self._graphics.num_max_complaints = \
self.simulation_info.num_max_complaints
self.rounds = 0
self.steps = 0
self.next_phase = "COASTPLAN"
self.prev_phase = None
self.worker = None
def run(self, rounds, steps):
assert rounds >= 0, "Rounds has to be a positive integer."
assert steps >= 0, "Steps has to be a positive integer."
assert steps > 0 or rounds > 0, "Rounds or steps needs to be positive."
self.controls.set_status(rounds, steps)
self.controls.set_buttons_processing()
self.rounds = rounds
self.steps = steps
if self.worker is None:
self.prev_phase = self.next_phase
self.info.set_current_phase(self.next_phase)
self.worker = WorkerThread(self._simulation, self)
def OnResult(self, event):
if not event.source is self.worker: # ongoing simulation was aborted
return
self.worker = None
self.simulation_info.map.grid = util.update_map(
self.simulation_info.map.grid, event.result.map.grid
)
self.next_phase = event.result.next_phase
handle_statistics(self.graphs, event.result.round, event.result.data)
self._graphics.set_map(self.simulation_info.map)
if event.result.phase == "HEARING":
self._graphics.add_votes(event.result.complaints)
self._graphics.update()
for m in event.result.messages:
self.messages.add(str(m))
newr = self.prev_phase == "LEARNING" and self.next_phase == "COASTPLAN"
if newr:
self._graphics.reset_votes()
if newr and self.rounds > 0:
self.rounds -= 1
elif self.rounds == 0:
self.steps -= 1
if self.rounds > 0 or self.steps > 0:
self.run(self.rounds, self.steps)
else:
self.controls.set_buttons_ready()
def OnStop(self, event):
self.reset_gui()
self._simulation = None
self.worker = None
self.simulation_info = None
def OnClose(self, event):
# TODO: Fix
self.Destroy()
locale.setlocale(locale.LC_ALL, 'ru_RU.utf-8')
sys.path.append('./events')
# import main modules
from data import Data
from say import Say
from info import Info
from ask import Ask
from act import Act
# init main modules
say = Say()
ask = Ask(say)
data = Data(ask)
info = Info(data)
act = Act(data, ask)
# import events modules
# from market import Market
# from distribute import Distribute
# from vizier import Vizier
from caravan import Caravan
# from church import Church
# from inheritance import Inheritance
#
# # init event modules
events = [
# Market(),
# Distribute(),
# Vizier(),
