def init_game():
if os.path.exists('saved.txt'):
win = open('saved.txt', 'r')
win_res = []
for i in win.readlines():
diff = i.split('\n')
win_res.append(diff[0])
if not win_res:
cont = controller.Controller(10, 10, 20, 'E')
else:
difficulty = win_res[0]
cont = controller.Controller(
*{
'E': (10, 10, 20, difficulty),
'M': (15, 15, 40, difficulty),
'H': (20, 20, 60, difficulty)
}[difficulty[0]])
if win_res[0] == 'E':
cont.load_all(win_res[1:11], win_res[11], win_res[12],
win_res[13])
if win_res[0] == 'M':
cont.load_all(win_res[1:16], win_res[16], win_res[17],
win_res[18])
if win_res[0] == 'H':
cont.load_all(win_res[1:21], win_res[21], win_res[22],
win_res[23])
else:
cont = controller.Controller(10, 10, 20, 'E')
cont.view.show()
def get_controller( args ) :
l = args[ 'lesson' ]
t = args[ 'tonic' ]
e = args[ 'evaluate' ]
if '' == l :
if e :
raise NameError( 'No --lesson to evaluate on.' )
ret = controller.Controller( t, '', False )
else :
ret = controller.Controller( t, l, e )
return ret
def __init__(self,
my_node,
conf_path,
routing_m_mod,
lookup_m_mod,
experimental_m_mod,
private_dht_name,
debug_level,
bootsrap_mode=False,
swift_port=0):
logging_conf.setup(conf_path, debug_level)
state_filename = os.path.join(conf_path, controller.STATE_FILENAME)
self.controller = controller.Controller(
VERSION_LABEL, my_node, state_filename, routing_m_mod,
lookup_m_mod, experimental_m_mod, private_dht_name, bootsrap_mode)
self.reactor = minitwisted.ThreadedReactor(
self.controller.main_loop, my_node.addr[1],
self.controller.on_datagram_received)
self.reactor.start()
self.swift_tracker_thread = None
if swift_port:
print 'Creating SwiftTracker'
self.swift_tracker_thread = swift_tracker.SwiftTracker(
self, swift_port)
self.swift_tracker_thread.start()
self.timestamps = []
self.max_num_sec = 0
self.max_num_min = 0
self.max_num_10min = 0
def __init__(self, progName = ''):
""" Load program (not doing anything yet),
and fill default command list """
# setup logging
logging.basicConfig(filename='../logs/AR2.warning.log', level=logging.WARNING)
logging.basicConfig(filename='../logs/AR2.debug.log', level=logging.DEBUG)
logging.basicConfig(filename='../logs/AR2.info.log', level=logging.INFO)
# load protocol
fileID = open('../conf/conf_commands.csv')
csvID = csv.reader(fileID, delimiter=',')
self._commands = {}
for row in csvID:
new_cmd = ProgramLine(int(row[0]), row[2], row[1], '', '')
self._commands[row[1]] = new_cmd
# initialise program
self.program_name = progName
self.program = program.Program()
# setup controller
self.number_of_joints = 6
self.controller = controller.Controller(self.number_of_joints)
def inittializeControllers():
for address in settings.topologyAddresses:
controllers[address] = c.Controller(address)
counter = 0
totalControllers = 4
for controller, v in collections.OrderedDict(sorted(
controllers.items())).items():
n1 = counter - 1
n2 = counter + 1
if n2 >= totalControllers:
n2 = 0
# print(n1, n2)
# print(v.controllerAddress)
v.setNeighbours([
controllers[settings.topologyAddresses[n1]],
controllers[settings.topologyAddresses[n2]]
])
counter = counter + 1
#v.calculateBorderGateways()
#v.resolvePathByDomain(controllers["10.2.2.130"], "3.5", "4.7")
#print(v.getSwitchPorts())
#print(controllers[settings.topologyAddresses[n1]].getSwitchPorts())
#print(v)
#print(settings.topologyAddresses[n1], settings.topologyAddresses[n2])
#print("|||||||||||||||||||||||||||||||||||||||||||||||||")
print("neighbours...")
paths = controllers["10.2.2.128"].resolvePathByDomain(
controllers["10.2.2.128"], controllers["10.2.2.128"], "2.1", "3.6", [])
def __init__(self):
datamodel.initModel()
appconst.GLADE_PATH = op.join(appconst.PATHS['share'], 'ui',
appconst.GLADE_FILE)
appconst.UI_PATH = appconst.PATHS['share']
self.controller = controller.Controller()
self.mainWindow = MainWindow(self.controller)
def __init__(self, profile_name=None):
storage_provider = storage.PickleProvider()
storage_factory = storage.Factory(storage_provider)
monitors_repository = monitors.Repository()
hardware_inventory = hardware.Inventory()
device_matcher = hardware.DeviceMatcher()
plugin_instance_factory = plugins.instance.Factory()
plugins_repository = plugins.Repository(monitors_repository,
storage_factory,
hardware_inventory,
device_matcher,
plugin_instance_factory)
unit_manager = units.Manager(plugins_repository, monitors_repository)
profile_factory = profiles.Factory()
profile_merger = profiles.Merger()
profile_locator = profiles.Locator(consts.LOAD_DIRECTORIES)
profile_loader = profiles.Loader(profile_locator, profile_factory,
profile_merger)
self._daemon = daemon.Daemon(unit_manager, profile_loader,
profile_name)
self._controller = controller.Controller(self._daemon)
self._dbus_exporter = None
self._init_signals()
self._pid_file = None
def __init__(self):
self.date_format = '%Y-%m-%d'
self.curr_session = Session()
self.curr_importer = importer.Importer(self.curr_session)
self.curr_importer.db_init()
self.curr_controller = controller.Controller(self.curr_session)
self.parser = argparse.ArgumentParser()
def __init__(self, profile_name = None, config = None):
self._dbus_exporter = None
storage_provider = storage.PickleProvider()
storage_factory = storage.Factory(storage_provider)
monitors_repository = monitors.Repository()
hardware_inventory = hardware.Inventory()
device_matcher = hardware.DeviceMatcher()
device_matcher_udev = hardware.DeviceMatcherUdev()
plugin_instance_factory = plugins.instance.Factory()
self.variables = profiles.variables.Variables()
self.config = GlobalConfig() if config is None else config
if self.config.get_bool(consts.CFG_DYNAMIC_TUNING):
log.info("dynamic tuning is enabled (can be overriden in plugins)")
else:
log.info("dynamic tuning is globally disabled")
plugins_repository = plugins.Repository(monitors_repository, storage_factory, hardware_inventory,\
device_matcher, device_matcher_udev, plugin_instance_factory, self.config, self.variables)
def_instance_priority = int(self.config.get(consts.CFG_DEFAULT_INSTANCE_PRIORITY, consts.CFG_DEF_DEFAULT_INSTANCE_PRIORITY))
unit_manager = units.Manager(plugins_repository, monitors_repository, def_instance_priority)
profile_factory = profiles.Factory()
profile_merger = profiles.Merger()
profile_locator = profiles.Locator(consts.LOAD_DIRECTORIES)
profile_loader = profiles.Loader(profile_locator, profile_factory, profile_merger, self.config, self.variables)
self._daemon = daemon.Daemon(unit_manager, profile_loader, profile_name, self.config, self)
self._controller = controller.Controller(self._daemon, self.config)
self._init_signals()
self._pid_file = None
def openFile(self):
widgetFO = QtWidgets.QWidget()
filename = QtWidgets.QFileDialog.getOpenFileName(
widgetFO, 'Open File', '~', "Audio *.wav files (*.wav)")
widgetFO.show()
global inputAudioFileName
inputAudioFileName = filename[0]
#check exist file
if ((len(filename[0])) > 0):
try:
file = open(inputAudioFileName)
except IOError as e:
print(u'не удалось открыть файл. Причина: ' + str(e))
widgetMB = QtWidgets.QWidget()
QtWidgets.QMessageBox.about(widgetMB, "Ошибка",
"Не удалось открыть файл!")
else:
with file:
#dialog
self.labelFileNameValue.setText(inputAudioFileName)
print(filename[0])
self.contr = controller.Controller(filename[0])
integratedLoudnessValue, luValue, rmsPeak = self.contr.getAudioInfo(
)
#self.label_LUvalue.setText(luValue)
self.lufsWidget.setPos(float(integratedLoudnessValue))
self.label_LUFSvalue.setText(integratedLoudnessValue)
self.label_RMSvalue.setText(rmsPeak)
def __init__(self,
my_node,
conf_path,
routing_m_mod,
lookup_m_mod,
experimental_m_mod,
private_dht_name,
debug_level,
auto_bootstrap=True,
bootstrap_mode=False,
swift_port=0):
logging_conf.setup(conf_path, debug_level)
self.controller = controller.Controller(
VERSION_LABEL, my_node, conf_path, routing_m_mod, lookup_m_mod,
experimental_m_mod, private_dht_name, bootstrap_mode)
self.reactor = minitwisted.ThreadedReactor(
self.controller.main_loop, my_node.addr[1],
self.controller.on_datagram_received)
if swift_port:
print 'Creating SwiftTracker'
swift_tracker.SwiftTracker(self, swift_port).start()
self.timestamps = []
self.max_num_sec = 0
self.max_num_min = 0
self.max_num_10min = 0
if auto_bootstrap:
# Overlay bootstrap
self.get_peers(None, self.controller._my_id, None, 0)
self.reactor.start()
def motor_2 ():
''' Define a task to run both motors in order. Configure the motor using the motor_driver.py file. Print the data to the serial port and plot the data in pc_main_lab3'''
# call class MotorDriver()
motor_2 = motor_driver.MotorDriver('C1', 20000)
# call class Controller()
ctr_2 = controller.Controller(0.01, 16000, 30)
## define the encoder that is used to read the motor position
encC = enc.Encoder('C')
# define x to be True to collect half of the data points an allow more time for printing data
x = True
while True:
# initialize the motor controller using class Controller()
motor_2.set_duty_cycle(ctr_2.outputValue(encC.read()))
# create a string of data to be plotted
data = '2, ' + str(encC.read()) + ', ' + str(utime.ticks_ms()) + '\r\n'
# print data every other pass through the while loop
if x == True:
print_task.put (data)
x = not x
# yield to another task and resume at this line
yield (0)
def start_run(self, **params):
if self._controller and self._controller.is_active:
raise ValueError('Run in progress')
pid_const_names = (
'prop',
'integral',
'bias',
)
pid_constants = {k: run_param(params, k) for k in pid_const_names}
run = attrdict.AttrDict(
id=str(uuid.uuid4()),
pid_constants=attrdict.AttrDict(**pid_constants),
notes=run_param(params, 'notes'),
target=run_param(params, 'target'),
ramp_up_target=run_param(params, 'ramp_up'),
start_time=datetime.datetime.now(),
end_time=None,
state=model.INITIALIZED,
)
self._run = run
self._controller = controller.Controller(self._run, self._loggers)
if self.is_daemon:
thread.start_new_thread(self._controller.control, ())
else:
self._controller.control()
def motor_1 ():
''' Define a task to run both motors in order. Configure the motor using the motor_driver.py file. Print the data to the serial port and plot the data in pc_main_lab3'''
# call class MotorDriver()
motor = motor_driver.MotorDriver('A10', 20000)
# call class Controller()
ctr = controller.Controller(0.01, 16000, 30)
## define the encoder that is used to read the motor position
encB = enc.Encoder('B')
# run the proportional contorller on the motor and feed the data into the shares and queues using put()
x = True
while True:
# set the motor duty cycle using class Controller()
motor.set_duty_cycle(ctr.outputValue(encB.read()))
# create a string of data to be plotted
data = '1, ' + str(encB.read()) + ', ' + str(utime.ticks_ms()) + '\r\n'
# print data every other pass through the while loop
if x == True:
print_task.put (data)
# yield to another task and resume at this line
yield (0)
def onInit(self):
self.log("Screensaver starting")
self.addon = xbmcaddon.Addon(scriptId)
if (self.addon.getSetting('setting_show_seconds') in ['false', 'False']):
self.showSeconds = False
else:
self.showSeconds = True
if (self.addon.getSetting('setting_show_random_sec') in ['false', 'False']):
self.randSec = False
else:
self.randSec = True
if (self.addon.getSetting('setting_show_random_hourmin') in ['false', 'False']):
self.randHourMin = False
else:
self.randHourMin = True
self.redrawInterval = int(self.addon.getSetting('setting_redraw_interval'))
self.hour1Color = (self.addon.getSetting('setting_color_col_1')+".png").lower()
self.hour2Color = (self.addon.getSetting('setting_color_col_2')+".png").lower()
self.min1Color = (self.addon.getSetting('setting_color_col_3')+".png").lower()
self.min2Color = (self.addon.getSetting('setting_color_col_4')+".png").lower()
self.secondsColor = (self.addon.getSetting('setting_color_col_5')+".png").lower()
self.monitor = self.ExitMonitor(self.exit, self.log)
self.allImages = list()
self.topX = 20
self.topY = 20
#self.log(addon_path)
self.showClock(False)
self.cont = controller.Controller(self.log, self.showClock, self.showSeconds, self.redrawInterval)
self.cont.start()
def main():
"""
Launch app from command line
"""
parser = argparse.ArgumentParser(description='Start the metric monitor.')
parser.add_argument("-c",
"--config",
type=str,
default="conf/local.cfg",
help="The configuration file to use")
args = parser.parse_args()
# Start up the controller
config = TheoriaConfig()
config.read(['conf/default.cfg', args.config])
ctrlr = controller.Controller(config)
ctrlr.start()
print 'Theoria started. Type CTRL-C to Exit.'
done = False
while not done:
try:
ctrlr.join(1)
except KeyboardInterrupt:
done = True
ctrlr.quit()
print 'Theoria Exiting.'
return 0
def test_hours_filter(self):
control = controller.Controller('../data/sample.csv',
'../data/paths0.png')
self.assertEquals(
control.hours_filter(datetime.time(int(1), int(27), int(9)),
datetime.time(int(1), int(28),
int(19))).shape[0], 16)
def __init__(self):
# Queue for data thread safe
self.data = queue.LifoQueue()
self.control_data = queue.LifoQueue()
# Create thread lock
# self.lock = threading.Lock()
# stop thread variable
self.stop = False
# variable to prevent multiple solutions form running
self.solving = False
# Create thread parameters
self.MPC_thread = threading.Thread(target=self.run, args=(), daemon=True)
# Controller state to pass into get_output function
self.controllerState = con.Controller()
# Optimal Control data updated by thread
self.u_pitch_star = 0.0
self.u_star = 0.0
# time.sleep(1)
# self.MPC_queue.put('worked')
# Initialize optimization parameters
self.initialize_optimization()
def test_drow(self):
control = controller.Controller('../data/sample.csv',
'../data/paths0.png')
control.draw_lines([([30, 100, 150, 200, 250], [30, 40, 60, 90, 150]),
([350, 300], [30, 50]), ([400, 300], [30, 100]),
([250, 150], [30, 50]), ([100, 250], [30, 50])],
False)
def main():
"""#############################################################################################
Program: DIARY PRINT
Files: main.py, controller.py, view.py, model.py, db_days, create_table_days.sql,
week_backward.png, week_forward.png, week_ home.pgn, diary.css.
Description: Prints personal diary files in html
Author: Pekka Paldánius (PP)
Environments: Linux Z87MPlus 3.16.0-38-generic #52~14.04.1-Ubuntu SMP
Fri May 8 09:43:57 UTC 2015
x86_64 x86_64 x86_64 GNU/Linux, python 3.4, SQLite 3.6.18,
Firefox Quantum 57.0.1(64-bit)
Remarks: This is computer hobbyists homework
Updates: 0.1 29.12.2017 (PP)
Global main function on main.py
################################################################################################"""
root = tk.Tk()
root.geometry("700x950+300+300")
root.title("Päiväkirja")
app = controller.Controller(root)
root.mainloop()
def debug_wrapper():
# initialize things
pygame.init()
pose_source = user_pose.FPS_Pose(two_d=True) # initialize position source
visar_controller = controller.Controller(
pose_source) # initialize controller
renderer = rendering.Renderer(visar_controller) # initialize renderer
# add pose source to update stack
visar_controller.add_update(pose_source.update)
# setup a static square object (from rendertest)
square1 = Debug_Static() # create a render module
renderer.add_module(square1) # add module to render stack
# setup dynamic (moving) square object (rendertest)
square2 = Debug_Dynamic() # create another module
visar_controller.add_update(square2.update) # add pose listener
renderer.add_module(square2) # add drawable to render stack
# setup a static square object with depth (from rendertest)
square3 = Debug_Depth() # create a render module
renderer.add_module(square3) # add module to render stack
# run the controller (spawns new thread)
#visar_controller.do_loop() # removed unused code
# run the renderer (blocks until code is done)
renderer.do_loop(visar_controller.kill_flag)
# program quit, kill pygame
pygame.quit()
def __init__(self, master=None):
self.root = master
self.top_left_frame = tk.Frame(self.root, width=410, height=100)
self.middle_left_frame = tk.Frame(self.root, width=410, height=20)
self.bottom_left_frame = tk.Frame(self.root, width=410, height=20)
self.top_left_frame.grid_propagate(False)
self.middle_left_frame.grid_propagate(False)
self.bottom_left_frame.grid_propagate(False)
self.top_left_frame.grid(row=0,
column=0,
sticky=tk.W + tk.E + tk.S + tk.N)
self.middle_left_frame.grid(row=1,
column=0,
sticky=tk.W + tk.E + tk.S + tk.N)
self.bottom_left_frame.grid(row=2,
column=0,
sticky=tk.W + tk.E + tk.S + tk.N)
self.root.grid_columnconfigure(0, weight=1)
self.root.grid_rowconfigure(0, weight=1)
self.root.grid_rowconfigure(1, weight=1)
self.root.grid_rowconfigure(2, weight=1)
self.root.title("GUI")
self.root.resizable(1, 0)
self.init_window()
self.controller = cont.Controller(self.console)
self.init_middle_frame()
def test_29_controller_pickle(self):
# actual returns True even though it is unable to load a csv
# this is a problem with the feedback provided in the model
cont = controller.Controller()
expected = True
actual = cont.pickle_modules('linkedlist.csv')
self.assertEqual(expected, actual)
def __init__(self):
self.robo = cartpole.cart_pole()
self.ctrl = controller.Controller()
self.learn_epoch_max = 10
self.epoch = 0
self.timeMax = 200
self.time = 0
def test_lqr():
control_spec = {
'feedback': 'LQR',
'params': {
'feedback': {
'Q': np.array([[1, 0], [0, 1]]),
'R': 1
}
}
}
model = Model(np.array([[0, 1], [1, 0]]), [[0], [1]])
dt = 0.01
x = np.array([[1], [1]])
goal_x = np.array([[0], [0]])
est_params = []
test_controller = controller.Controller(control_spec, model)
output = test_controller.control(dt, x, goal_x, est_params)
# expected results
K, S, E = control.lqr(model.A, model.B,
control_spec['params']['feedback']['Q'],
control_spec['params']['feedback']['R'])
expec_output = -K @ x
assert output == expec_output
def main():
repo = repository.Repository()
contr = controller.Controller(repo)
view = ui.UI(contr, repo)
view.menu()
def setUp(self):
self.read = reader.FileReader()
self.valid = validator.Validator()
self.db = database.DatabaseMaker()
self.con = controller.Controller()
self.cmd = command_line.DomainCmd(self.con)
self.chart = display.PyGal()
def __init__(self, dht_addr, conf_path, routing_m_mod, lookup_m_mod,
private_dht_name, debug_level):
logging_conf.setup(conf_path, debug_level)
self.controller = controller.Controller(dht_addr, conf_path,
routing_m_mod, lookup_m_mod,
private_dht_name)
self.controller.start()
def main():
# Define the options for DeeProtein
parser = argparse.ArgumentParser(description='Options to run DeeProtein')
set_default_options(config_file=os.path.join(sys.path[0], 'config.JSON'),
parser=parser)
# then parse the args
FLAGS = parser.parse_args()
logger = set_up_logger(FLAGS.info_path, FLAGS.modelname)
controller = cont.Controller(FLAGS)
if FLAGS.mask == 'True':
logger.debug('mask')
controller.evaluate_masked_set(filepath=FLAGS.validdata)
elif FLAGS.infer == 'True':
logger.debug('infer')
controller.init_for_infer()
controller.interactive_inference()
elif FLAGS.sequence:
logger.debug('infering single sequence')
controller.init_for_infer()
preds = controller.infer(FLAGS.sequence)
with open(os.path.join(FLAGS.info_path, 'results.txt'), 'w') as ofile:
ofile.write(preds)
logger.debug(preds)
elif FLAGS.test == 'True':
logger.debug('test')
controller.test()
else:
logger.debug('train')
controller.train()
logger.info('Done.')
def directions_return(self):
d = self.locationlist
k = c.Controller()
ret_direc_value = k.return_direction(d)
# creates a new window to print directions
self.master = Tk()
p = ret_direc_value
self.master.minsize(width=400, height=400)
# creates a new label
lab1 = Label(self.master,
text='Directions from {} to {} is'.format(
self.from_loc, self.to_loc),
font=("Helvetica", 14))
lab1.grid(row=0, column=0)
# shows as text in the window
lab2 = Label(self.master, text=p, font=("Helvetica", 12))
lab2.grid(row=3, column=0)
# creates a new label
lab4 = Label(self.master,
text='Have a safe journey !!',
font=("Helvetica", 14))
lab4.grid(row=6, column=0)
# creates a new button
But1 = Button(self.master,
text='Back to main menu',
command=self.destroy_dir)
But1.grid(row=8, column=0)
mainloop()
