import time
from ConfigReader import ConfigReader
from GitlabAPI import get_image_info
from caching import Cacher
from Exceptions import ErrorConnectingAPIException, ImageNotFoundException
from Docker import refresh_image, restart_outdated_containers, restart_services, run_image_once, cleanup_exited_containers
from Logger import Logger
config_reader = ConfigReader()
cacher = Cacher()
registries = config_reader.get_registries()
logger = Logger()
def register_images():
for registry in registries:
for image in registry['images']:
image_info = get_image_info(registry['user'], registry['project'],
image['tag'], registry['apiToken'])
if image_info.get('error'):
raise ErrorConnectingAPIException('Could not connect to API!')
cacher.update_or_insert_image(image_info['path'],
image_info['revision'])
refresh_image(image_info['location'])
restart_services(image_info['location'])
restart_outdated_containers(image_info['location'],
image_info['revision'])
cleanup_exited_containers()
logger.log_line(
f'Registered and updated image {image_info["location"]}')
def main():
# Parse all command line arguments using the argparse module
parser = argparse.ArgumentParser(description='')
parser.add_argument("-c", "--config", help="Configuration file")
args = parser.parse_args()
if args.config is None:
print '[ hps-learn ]: A configuration file needs to be specified!'
sys.exit(2)
# Parse the configuration
config_reader = ConfigReader(args.config)
# If signal files were specified, open them and get the specified ROOT
# TTree objects. Otherwise, warn the user that no signal files were
signal_files = config_reader.get_signal_files()
signal_root_files = list()
signal_root_trees = list()
if signal_files:
for signal_file, tree_name in signal_files.iteritems():
print "[ hps-learn ]: Loading signal file " + signal_file + " with TTree name " + tree_name
signal_root_files.append(root.TFile(signal_file))
signal_root_trees.append(signal_root_files[-1].Get(tree_name))
else:
print "[ hps-learn ]: At least a single signal file needs to be specified."
sys.exit(2)
# If background files were specified, open them and get the specified ROOT
# TTree objects. Otherwise, warn the user that no background files were
# specified and exit.
bkg_files = config_reader.get_background_files()
bkg_root_files = list()
bkg_root_trees = list()
if bkg_files:
for bkg_file, tree_name in bkg_files.iteritems():
print "[ hps-learn ]: Loading background file " + bkg_file + " with TTree name " + tree_name
bkg_root_files.append(root.TFile(bkg_file))
bkg_root_trees.append(bkg_root_files[-1].Get(tree_name))
else:
print "[ hps-learn ]: At least a single background file needs to be specified."
sys.exit(2)
root.TMVA.Tools.Instance()
tmva_file = root.TFile("tmva_output.root", "RECREATE")
factory = root.TMVA.Factory(
"TMVA_Analysis", tmva_file, ":".join([
"!V", "!Silent", "Color", "DrawProgressBar",
"Transformations=I;D;P;G;D", "AnalysisType=Classification"
]))
for signal_tree in signal_root_trees:
factory.AddSignalTree(signal_tree)
for bkg_tree in bkg_root_trees:
factory.AddBackgroundTree(bkg_tree)
variables = config_reader.get_training_variables()
for variable, variable_type in variables.iteritems():
print "Adding training variable " + variable + " of type " + variable_type
factory.AddVariable(variable, variable_type)
signal_cuts = root.TCut("")
bkg_cuts = root.TCut("")
factory.PrepareTrainingAndTestTree(
signal_cuts, bkg_cuts, ":".join([
"nTrain_Signal=0", "nTrain_Background=0", "SplitMode=Random",
"NormMode=NumEvents", "!V"
]))
method = factory.BookMethod(root.TMVA.Types.kMLP, "MLP_ANN", "")
factory.TrainAllMethods()
factory.TestAllMethods()
factory.EvaluateAllMethods()
from kafka.errors import FailedPayloadsError
try:
with open("data/AFINN-96.txt") as file:
sentiment_data = dict(csv.reader(file, delimiter='\t'))
for key in sentiment_data:
sentiment_data[key] = int(sentiment_data[key])
except IOError as e:
logging.error("Could not open sentiment data file " + str(e.args))
exit(1)
except ValueError:
logging.error("Sentiment data file not valid")
exit(1)
config = ConfigReader("config.json")
zookeeper_url = "{:s}:{:s}".format(config.get_key("ZOOKEEPER_HOST"), config.get_key("ZOOKEEPER_PORT"))
kafka_topic = config.get_key("KAFKA_TOPIC")
output_topic = config.get_key("KAFKA_OUTPUT_TOPIC")
sc = SparkContext(appName="PythonTweetCleaner")
sc.setLogLevel("ERROR")
ssc = StreamingContext(sc, 10)
kafka_params = {"startingOffsets": "earliest"}
kafkaStream = KafkaUtils.createStream(ssc, zookeeper_url, 'spark-streaming',
{kafka_topic: 1}, kafka_params)
def __init__(self):
print("Tekken Bot Starting...")
is_windows_7 = 'Windows-7' in platform.platform()
self.tekken_config = ConfigReader("frame_data_overlay")
self.is_draggable_window = self.tekken_config.get_property("independent_window_mode", True, lambda x: not "0" in str(x))
self.is_minimize_on_lost_focus = self.tekken_config.get_property("minimize_on_lost_focus", True, lambda x: not "0" in str(x))
self.is_transparency = self.tekken_config.get_property("transparency", not is_windows_7, lambda x: not "0" in str(x))
self.enable_nerd_data = self.tekken_config.get_property("data_for_nerds", False, lambda x: not "0" in str(x))
self.launcher = FrameDataLauncher(self.enable_nerd_data)
self.overlay_visible = False
Tk.__init__(self)
self.wm_title("Tekken Bot: Frame Data Overlay")
self.attributes("-topmost", True)
#self.background_color = '#002B36'
self.background_color = 'gray10'
if self.is_transparency:
self.wm_attributes("-transparentcolor", "white")
self.attributes("-alpha", "0.75")
self.tranparency_color = 'white'
else:
if is_windows_7:
print("Windows 7 detected. Disabling transparency.")
self.tranparency_color = self.background_color
self.configure(background=self.tranparency_color)
self.w = 820
self.h = 96
if self.enable_nerd_data:
self.w += 400
self.geometry( str(self.w) + 'x' + str(self.h))
self.iconbitmap('TekkenData/tekken_bot_close.ico')
if not self.is_draggable_window:
self.overrideredirect(True)
self.s = Style()
self.s.theme_use('alt')
self.s.configure('.', background=self.background_color)
self.s.configure('.', foreground='black')
Grid.columnconfigure(self, 0, weight=0)
Grid.columnconfigure(self, 1, weight=0)
Grid.columnconfigure(self, 2, weight=0)
Grid.columnconfigure(self, 3, weight=1)
Grid.columnconfigure(self, 4, weight=0)
Grid.columnconfigure(self, 5, weight=0)
Grid.columnconfigure(self, 6, weight=0)
Grid.rowconfigure(self, 0, weight=1)
Grid.rowconfigure(self, 1, weight=0)
self.s.configure('TFrame', background=self.tranparency_color)
self.fa_p1_var = self.create_frame_advantage_label(1)
self.fa_p2_var = self.create_frame_advantage_label(5)
self.l_margin = self.create_padding_frame(0)
self.r_margin = self.create_padding_frame(2)
self.l_seperator = self.create_padding_frame(4)
self.r_seperator = self.create_padding_frame(6)
self.text = self.create_textbox(3)
self.stdout = sys.stdout
self.redirector = TextRedirector(self.stdout, self.text, self.s, self.fa_p1_var, self.fa_p2_var)
self.text.configure(state="normal")
self.text.delete("1.0", "end")
self.text.insert("1.0", "{:^5}|{:^8}|{:^9}|{:^8}|{:^5}|{:^5}|{:^5}|{}\n".format(" input ", "type", "startup", "block", "hit", "CH", "active", "notes"))
self.text.configure(state="disabled")
MediaPlayer.PlayingFolder = 0
MediaPlayer.SetVolume(volume)
while True:
MediaPlayer.PlayingFile = random()%10 + prefix_file
MediaPlayer.PlayFile()
sleep(0.1)
if(MediaPlayer.BusyPin.value() == 0): break
while MediaPlayer.BusyPin.value() == 0: pass
DFPlayerMiniCommander = MicroPlayer()
NTPTime = NTPTimeClass()
Log = LogWriter("/logs/log.txt")
Config = ConfigReader("/configs/config.txt")
if(len(Config.Errors) != 0):
Log.Write("Ошибка(-и) загрузки конфига! :-(\n - ", "!!!ERROR!!!")
for i in Config.Errors: Log.Write(i, "!!!ERROR!!!")
MediaPlayer = MediaPlayerClass(DFPlayerMiniCommander, 4, [200], 1)
PlayMessage(Config.Volume[7 -1], 109)
raise ValueError("Ошибка загрузки конфига! :-(")
else: Log.Write("Конфиг загружен! =-)", "CONFIG", TimeWithMyTimeZone(NTPTime.GetNTPTime(), Config.TimeZone))
MediaPlayer = MediaPlayerClass(DFPlayerMiniCommander, 4, [200], 1)
wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.ifconfig((Config.WLAN_static_ip, Config.WLAN_netmask, Config.WLAN_gateway, Config.WLAN_DNS_server))
if not wifi.isconnected():
wifi.connect(Config.WLAN_id, Config.WLAN_password)
def load_configs(self, config_file):
# load some values form the config file
self.config_reader = ConfigReader(config_file)
self.x_lb = str2list(self.config_reader.get_value_string("system.states.first_symbol"))
self.x_ub = str2list(self.config_reader.get_value_string("system.states.last_symbol"))
self.x_eta = str2list(self.config_reader.get_value_string("system.states.quantizers"))
self.u_lb = str2list(self.config_reader.get_value_string("system.controls.first_symbol"))
self.u_ub = str2list(self.config_reader.get_value_string("system.controls.last_symbol"))
self.u_eta = str2list(self.config_reader.get_value_string("system.controls.quantizers"))
self.specs_formula = self.config_reader.get_value_string("specifications.ltl_formula")
self.X_initial = self.config_reader.get_value_string("system.states.initial_set")
self.X_initial_HR = str2hyperrects(self.X_initial)[0]
self.SCREEN_WIDTH = int(self.config_reader.get_value_string("simulation.window_width"))
self.SCREEN_HEIGHT = int(self.config_reader.get_value_string("simulation.window_height"))
self.title = self.config_reader.get_value_string("simulation.widow_title")
self.step_time = float(self.config_reader.get_value_string("simulation.step_time"))
self.skip_aps = self.config_reader.get_value_string("simulation.skip_APs").replace(" ", "").split(",")
self.visualize_3rd_dim = ( "true" == self.config_reader.get_value_string("simulation.visualize_3rdDim"))
self.model_image = self.config_reader.get_value_string("simulation.system_image")
self.model_image_scale = float(self.config_reader.get_value_string("simulation.system_image_scale"))
self.controller_file = self.config_reader.get_value_string("simulation.controller_file")
self.use_ODE = ( "true" == self.config_reader.get_value_string("simulation.use_ode"))
self.model_dump_file = self.config_reader.get_value_string("simulation.model_dump_file")
if(self.model_dump_file == "" or self.model_dump_file == None):
self.use_model_dump = False
else:
self.use_model_dump = True
self.x_0_str = self.config_reader.get_value_string("simulation.initial_state")
if self.x_0_str == "center":
self.x_0 = self.X_initial_HR.get_center_element()
elif self.x_0_str == "random":
self.x_0 = self.X_initial_HR.get_random_element()
else:
self.x_0 = str2list(self.x_0_str)
# create a quantizer and an ode solver
self.qnt_x = Quantizer(self.x_lb, self.x_eta, self.x_ub)
self.qnt_u = Quantizer(self.u_lb, self.u_eta, self.u_ub)
if self.use_ODE:
self.ode = RungeKuttaSolver(self.sys_dynamics, 5)
# configs for the arena
self.PADDING = 40
self.ZERO_BASE_X = self.PADDING
self.ZERO_BASE_Y = self.PADDING
self.X_GRID = (self.SCREEN_WIDTH-2*self.PADDING)/self.qnt_x.get_widths()[0]
self.Y_GRID = (self.SCREEN_HEIGHT-2*self.PADDING)/self.qnt_x.get_widths()[1]
self.ARENA_WIDTH = (self.qnt_x.get_widths()[0])*self.X_GRID
self.ARENA_HIGHT = (self.qnt_x.get_widths()[1])*self.Y_GRID
self.X_SCALE_FACTOR = self.ARENA_WIDTH/(self.x_ub[0] - self.x_lb[0] + self.x_eta[0])
self.Y_SCALE_FACTOR = self.ARENA_HIGHT/(self.x_ub[1] - self.x_lb[1] + self.x_eta[1])
self.Z_SCALE_FACTOR = 180.0/math.pi # from rad to deg
self.arena_mdl_lb = self.translate_sys_to_arena(self.x_lb)
self.arena_mdl_ub = self.translate_sys_to_arena(self.x_ub)
# others: subsets
self.subset_names = self.config_reader.get_value_string("system.states.subsets.names").replace(" ","").split(",")
self.subset_HRs = []
for subset_name in self.subset_names:
skip = False
for skip_ap in self.skip_aps:
if skip_ap == subset_name:
skip = True
if skip:
continue
subset_str = self.config_reader.get_value_string("system.states.subsets.mapping_" + subset_name)
if subset_str == '':
continue
HRs = str2hyperrects(subset_str)
HRs_modified = []
for HR in HRs:
conc_lb = HR.get_lb()
conc_ub = HR.get_ub()
for i in range(len(self.x_lb)):
if conc_lb[i] < self.x_lb[i]:
conc_lb[i] = self.x_lb[i] - self.x_eta[i]/2
if conc_ub[i] > self.x_ub[i]:
conc_ub[i] = self.x_ub[i] + self.x_eta[i]/2
lb = self.translate_sys_to_arena(conc_lb)
ub = self.translate_sys_to_arena(conc_ub)
HR.set_lb(lb)
HR.set_ub(ub)
HRs_modified.append(HR)
self.subset_HRs.append(HRs_modified)
def __init__(self, config_file):
"""Initialize Deepy3d class with a configuration file."""
self.config = ConfigReader(config_file)
PORT = sys.argv[1]
COMMIT_HASH = sys.argv[2].strip('"')
BRANCH_NAME = sys.argv[3].strip('"')
ACTIVE_NODE_PATH = sys.argv[4].strip('"')
ACTIVE_SELECTION_PATHS = []
if sys.argv[4] != '""':
ACTIVE_SELECTION_PATHS = sys.argv[4].strip('"').split(',')
if ACTIVE_SELECTION_PATHS[0] == '':
ACTIVE_SELECTION_PATHS.pop(0)
NAMESPACE = sys.argv[5].strip('"')
logger.debug('commit-hash: {0}'.format(COMMIT_HASH))
logger.debug('branch-name: {0}'.format(BRANCH_NAME))
logger.debug('active-node-path: {0}'.format(ACTIVE_NODE_PATH))
logger.debug('active-selection-paths: {0}'.format(ACTIVE_SELECTION_PATHS))
logger.debug('name-space: {0}'.format(NAMESPACE))
# Create an instance of WebGME and the plugin
webgme = WebGME(PORT, logger)
plugin = ConfigReader(webgme, COMMIT_HASH, BRANCH_NAME, ACTIVE_NODE_PATH,
ACTIVE_SELECTION_PATHS, NAMESPACE)
# Do the work
plugin.main()
# Finally disconnect from the zmq-server
webgme.disconnect()
time.sleep(30)
registered_login_creatrole(device)
cloth_select(device)
dance_guide(device)
mall_guide(device)
itembag_guide(device)
quest_guide(device)
end_guide(device)
mylogger.info('test..end!')
if __name__ == '__main__':
apkname = 'App/L5_518_All.apk'
mylogger = Logger(logger='test_ddl').getlog()
adb = ADB()
config = ConfigReader(os.getcwd() + '/Config/Config.ini')
standard_width = config.getdic('standard')['standard_width']
standard_high = config.getdic('standard')['standard_high']
mylogger.info('standard_width=%s, standard_high=%s' %
(standard_width, standard_high))
component = adb.get_app_package_info(apkname)
package_name = component.split("/")[0]
mylogger.info('component=%s' % component)
devices_list = adb.find_devices()
if devices_list:
for i in range(len(devices_list)):
mylogger.info('devices_list[%s]= %s' % (i, devices_list[i]))
port_list = range(5555, 5555 + len(devices_list))
test_device = Device(devices_list[i], port_list[i])
width_high = adb.get_device_lcd_size(devices_list[i])
mylogger.info('real_width=%s, real_high=%s' %
