def main():
if args.mode == 'train':
print('Training ...')
train_set = DehazeTrain(args.dataset,
'train',
'all',
resize=args.resize)
valid_set = DehazeTrain(args.dataset,
'valid',
'all',
resize=args.resize)
train_data = DataLoader(dataset=train_set,
batch_size=args.bs,
shuffle=True)
valid_data = DataLoader(dataset=valid_set, batch_size=args.bs)
manager = Manager(model, args)
manager.train(train_data, valid_data)
else:
print('Predicting ...')
test_set = DehazeTest(args.dataset)
manager = Manager(model, args)
manager.predict(test_set)
def setUp(self):
self.managers = [
Manager("Bill", "Gates", 1000, 10),
Manager("Mark", "Zuckerberg", 900, 3),
Manager("Sergey", "Brin", 900, 1),
Manager("Steve", "Jobs", 800, 8)
]
self.depart = Department(self.managers)
self.employees = [
Designer("tom",
"taylor",
800,
10,
self.managers[0],
effect_coeff=0.5),
Developer("dev1", "java", 500, 2, self.managers[0]),
Developer("dev2", "js", 500, 6, self.managers[0]),
Designer("armani",
"jeans",
1200,
3,
self.managers[1],
effect_coeff=1),
Designer("dolce", "gabbana", 800, 6, self.managers[1]),
Developer("dev3", "basic", 500, 0.5, self.managers[1]),
Developer("dev4", "python", 500, 6)
]
self.employees_salary_expected = [730, 500, 1100]
self.managers_salary_expected = [1870]
self.wrong_list = ["vasya", "petya", "kolya", 15, True]
def main():
# model = get_mlp(args.input_dim, args.model)
model = get_rnn(args.input_dim, args.model, args.bs)
transform = Transform_04()
if args.mode == 'train':
print('Training ...')
train_set = TrainData('train', transform)
valid_set = TrainData('valid', transform)
train_data = DataLoader(dataset=train_set,
batch_size=args.bs,
shuffle=True,
drop_last=True)
valid_data = DataLoader(dataset=valid_set,
batch_size=args.bs,
drop_last=True)
manager = Manager(model, args)
manager.train(train_data, valid_data)
else:
print('Predicting ...')
test_set = TestData(transform)
test_data = DataLoader(dataset=test_set, batch_size=args.bs)
manager = Manager(model, args)
manager.predict(test_data)
def __init__(self, id1: 'int' = 1, id2: 'int' = 2):
self.__database = Database()
self.__manager1 = Manager(id1, self.__database.before_game(id1))
self.__manager2 = Manager(id2, self.__database.before_game(id2))
self.__overs = 20
self.__engine = Engine()
self.__scoreboard = ScoreBoard(self.__manager1.get_team(),
self.__manager2.get_team())
def test_employees_can_be_sorted(self):
company = [
Manager('Zeesha', 'Crim', 45345, 436345, 'Director', 45345345),
Employee('Foo', 'Boo', 345345, 345345),
Manager('Yury', 'Ystinchuk', 355345, 43534643, 'QA Manager',
4353443),
Employee('Alexey', 'Milyukov', 45345345, 345345),
]
sorted_company = sorted(company)
assert sorted_company[0] == company[1]
assert sorted_company[1] == company[0]
assert sorted_company[2] == company[3]
assert sorted_company[3] == company[2]
def main():
streamers = config.loadStreamers()
console_manager = Manager(streamers, "console")
console_manager.start()
socket = zmq.Context.instance().socket(zmq.REP)
socket.bind("tcp://*:6969")
zmq_manager = Manager(streamers, "zmq", socket)
zmq_manager.start()
http_manager = HTTPManager(streamers)
http_manager.start()
def main():
managers = [
Manager("Bill", "Gates", 1000, 10),
Manager("Mark", "Zuckerberg", 900, 3),
Manager("Sergey", "Brin", 900, 1),
Manager("Steve", "Jobs", 800, 8)
]
employees = [
Designer("tom", "taylor", 800, 10, managers[0], effect_coeff=0.5),
Developer("dev1", "java", 500, 2, managers[0]),
Developer ("dev2", "js", 500, 6, managers[0]),
Designer("armani", "jeans", 1200, 3, managers[1], effect_coeff=1),
Designer("dolce", "gabbana", 800, 6, managers[1]),
Developer ("dev3", "basic", 500, 0.5, managers[1]),
Developer ("dev4", "python", 500, 6)
]
depart = Department(managers)
wrong_list = ["vasya","petya","kolya", 15, True]
depart.give_salary()
depart.add_team_members(managers[-1], employees[-1::]) # employees[-1].set_manager(managers[-1])
depart.give_salary()
depart.add_team_members(managers[-2], employees[-1::]) #employees[-1].set_manager(managers[-2])
depart.give_salary()
depart.add_team_members(managers[1], employees[-1::]) # employees[-1].set_manager()
depart.give_salary()
depart.add_team_members(managers[0], employees)
depart.give_salary()
depart.add_team_members(managers[-1], [])
depart.give_salary()
depart.add_team_members(managers[-1], wrong_list)
depart.give_salary()
wrong_list.extend(employees[-1::])
depart.add_team_members(managers[-1], wrong_list)
depart.give_salary()
depart.add_team_members(managers[-1], managers[:-1:])
depart.give_salary()
def shell():
# read in command line arguments to load in
# python test.txt or smth
output = open("outfile.txt", "w")
output = open("outfile.txt", "a")
if len(sys.argv) == 2 and sys.argv[1] is not None:
with open(sys.argv[1], 'r') as file:
lines = file.readlines()
for line in lines:
s = line.rstrip().split(" ")
if (s[0] == "in"):
manager = Manager(output, True)
elif (s[0] == "cr"):
manager.create(int(s[1]))
elif (s[0] == "de"):
manager.destroy(int(s[1]))
elif (s[0] == "rq"):
manager.request(int(s[1]), int(s[2]))
elif (s[0] == "rl"):
manager.release(int(s[1]), int(s[2]))
elif (s[0] == "to"):
manager.timeout()
else:
while True:
print("> ", end="")
s = input()
s = s.rstrip().split(" ")
if (s[0] == "in"):
manager = Manager(outfile=None, mode=False)
elif (len(s) == 2 and s[0] == "cr" and s[1] is not None):
manager.create(int(s[1]))
elif (len(s) == 2 and s[0] == "de" and s[1] is not None):
manager.destroy(int(s[1]))
elif (len(s) == 3 and s[0] == "rq" and s[1] is not None):
manager.request(int(s[1]), int(s[2]))
elif (len(s) == 3 and s[0] == "rl" and s[1] is not None):
manager.release(int(s[1]), int(s[2]))
elif (s[0] == "to"):
manager.timeout()
elif (s[0] == "ready"):
manager.printRL()
elif (s[0] == "pcb"):
manager.printPCB()
elif (s[0] == "rcb"):
manager.printRCB()
class doc(models.Model):
class Meta:
app_label = "tests"
ordering = ("-id", )
title = models.CharField(
max_length=300,
blank=False,
null=False,
)
content = models.TextField(
blank=True,
null=True,
)
summary = models.TextField(
blank=True,
null=True,
)
time_added = models.DateTimeField()
path = models.FilePathField(
blank=False,
null=False,
)
email = models.EmailField(
blank=True,
null=True,
)
objects_search = Manager(index_model="doc_index")
def __unicode__(self):
return "%s" % self.title
def test_disks_to_flip(self):
board = Board(8)
manager = Manager()
moves = manager.get_possible_moves(board, Disk.DARK)
move = moves[0]
disks = manager.disks_to_flip(board, move, Disk.DARK)
self.assertEqual(disks, [(3, 4)])
def test_passive():
def on_device_found(adapter, address, values):
print "on device found"
print "adapter", adapter
print "address", address
print "values", values
def on_device_created(adapter, dev_path):
print "on device created"
print "adapter", adapter
print "dev_path", dev_path
from manager import Manager
from adapter import Adapter
manager = Manager()
adapter = Adapter(manager.get_default_adapter())
adapter.set_powered(True)
adapter.set_discoverable(True)
adapter.set_pairable(True)
# print "adapter properties:\n %s" % adapter.get_properties()
adapter.connect("device-found", on_device_found)
adapter.connect("device-created", on_device_created)
mainloop = gobject.MainLoop()
mainloop.run()
def main(server_port, num_of_clients):
manager = Manager(num_of_clients, server_port)
manager.start()
input("Press ENTER to exit\n")
# If achieved here user wants to exit
print("Stopping gracefully..")
manager.stop()
def boot(self):
try:
self.interface = Interface()
self.system = System()
self.manager = Manager(self.system, self.interface)
except:
self.stop('Failed to boot Termud:\n\n' + traceback.format_exc())
def __init__(self,
board_size=8,
player1_type=HumanPlayer,
player2_type=HumanPlayer):
self.console = CLI()
self.board = Board(board_size)
self.manager = Manager()
self.p1 = player1_type(Disk.DARK)
if issubclass(player1_type, HumanPlayer):
self.p1.set_console(self.console)
if issubclass(player1_type, SimplePlayer):
self.p1.set_manager(self.manager)
if issubclass(player1_type, Player02):
self.p1.set_minimax_variables(self.manager)
self.p2 = player2_type(Disk.LIGHT)
if issubclass(player2_type, HumanPlayer):
self.p2.set_console(self.console)
if issubclass(player2_type, SimplePlayer) or issubclass(
player2_type, Player02):
self.p2.set_manager(self.manager)
if issubclass(player2_type, Player02):
self.p2.set_minimax_variables(self.manager)
self.current_player = self.p1
def __init__(self, session, args = 0):
self.printconfig()
self.session = session
Screen.__init__(self, session)
Screen.setTitle(self, _("AutoBouquetsMaker"))
self["background"] = Pixmap()
self["action"] = Label(_("Starting scanner"))
self["status"] = Label("")
self["progress"] = ProgressBar()
self["progress_text"] = Progress()
self.frontend = None
self.rawchannel = None
self.postScanService = None
self.providers = Manager().getProviders()
# dependent providers
self.dependents = {}
for provider_key in self.providers:
if len(self.providers[provider_key]["dependent"]) > 0 and self.providers[provider_key]["dependent"] in self.providers:
if self.providers[provider_key]["dependent"] not in self.dependents:
self.dependents[self.providers[provider_key]["dependent"]] = []
self.dependents[self.providers[provider_key]["dependent"]].append(provider_key)
# get ABM config string including dependents
self.abm_settings_str = self.getABMsettings()
self.actionsList = []
self.onFirstExecBegin.append(self.firstExec)
def set_team_personnel(self):
"""Set the personnel working for this team.
In this method, we set attributes pertaining to the actual baseball-class objects
corresponding to the employees of this organization. This method may be called any
time an employee in the organization quits, retires, is fired, or dies.
"""
# Set team owner
owner_person = next(e for e in self.organization.employees
if isinstance(e, BaseballTeamOwner)).person
self.owner = Owner(
person=owner_person
) if not owner_person.team_owner else owner_person.team_owner
# Set manager
manager_person = next(e for e in self.organization.employees
if isinstance(e, BaseballManager)).person
self.manager = (Manager(person=manager_person, team=self) if
not manager_person.manager else manager_person.manager)
# Set scout
scout_person = next(e for e in self.organization.employees
if isinstance(e, BaseballScout)).person
self.scout = Scout(
person=scout_person,
team=self) if not scout_person.scout else scout_person.scout
# Set personnel attribute
self.personnel = {self.owner, self.manager, self.scout}
for p in self.personnel:
p.team = self
def store_temp(need_sleep: bool = False):
"""
makes a database entry at the current time
stats is a table where each row stores:
core: int, processor: int, processor_usage: float, heaviest_process: str, ...
... heaviest_process_usage: float, temperature: int
:param need_sleep: bool, pass True if reading is taken within 3 seconds of python boot
:return: None
"""
core_map = get_cpu_map()
time = datetime.now()
temperatures = get_temp(need_sleep)
processes = get_processes()
stats = [(core_map[cpu], cpu, processes[cpu]["processor_usage"],
processes[cpu]["command"], processes[cpu]["process_usage"],
temperatures[core_map[cpu]]) for cpu in core_map.keys()]
with Manager(DATABASE_ADRESS) as manager:
client = manager.get_client(gethostname())
for core, cpu, cpu_usage, process, process_usage, temperature in stats:
manager.add_cpu(client, core, cpu, cpu_usage, process,
process_usage, temperature, time)
def test_with_a_process():
queue = Queue()
queue.put(('logthis', 'init message'))
manager = Manager(queue)
manager.bind('logthis', logger_handler)
manager.run()
p = Process(target=pulsar, args=(queue, 2,))
print(p.is_alive())
p.start()
print(p.is_alive())
try:
while True:
command = input()
if command == 'stop':
raise KeyboardInterrupt
except KeyboardInterrupt as e:
print('start stopping')
p.terminate()
manager.stop()
for th in manager.threads:
th.join()
manager.listen_thread.join()
print('all stop')
def run(render=False):
sess = tf.InteractiveSession()
init_global_bullet_policy()
managers = []
for i in range(NUM_WORKERS):
manager = Manager(sess, i)
managers.append(manager)
# init variables
sess.run(tf.global_variables_initializer())
worker_threads = []
for i in range(len(managers)):
manager = managers[i]
if len(managers) > 1 and i == 0:
job = lambda: manager.test(render=render)
else:
job = lambda: manager.train()
t = threading.Thread(target=job)
t.start()
worker_threads.append(t)
# wait
COORD = tf.train.Coordinator()
COORD.join(worker_threads)
def run_experiment(env_info,
agent_info,
num_episodes=5000,
experiment_name=None,
plot_freq=100,
true_values_file=None,
value_error_threshold=1e-8):
env = CliffWalkEnvironment
agent = TDAgent
rl_glue = RLGlue(env, agent)
rl_glue.rl_init(agent_info, env_info)
manager = Manager(env_info,
agent_info,
true_values_file=true_values_file,
experiment_name=experiment_name)
for episode in range(1, num_episodes + 1):
rl_glue.rl_episode(0) # no step limit
if episode % plot_freq == 0:
values = rl_glue.agent.agent_message("get_values")
manager.visualize(values, episode)
values = rl_glue.agent.agent_message("get_values")
if true_values_file is not None:
# Grading: The Manager will check that the values computed using your TD agent match
# the true values (within some small allowance) across the states. In addition, it also
# checks whether the root mean squared value error is close to 0.
manager.run_tests(values, value_error_threshold)
return values
def main():
m = Manager('config.ini')
m.login_upstox()
o = GannNiftyOptions()
o.setup(m.client)
m.add_strategy(o)
m.main_loop()
def start_game(self,flag = 0):
'''
Game will get started for given status
'''
if flag==0:
self.reset_status()
_ = Manager(self)
def test_office(self):
galia = Manager("galia")
newOffice = Office()
with pytest.raises(Exception):
galia.work(5)
galia.work([1, 2, 3])
galia.work(Office())
def run_experiment(env_info,
agent_info,
num_episodes=5000,
experiment_name=None,
plot_freq=100,
true_values_file=None,
value_error_threshold=1e-8):
env = CliffWalkEnvironment
agent = TDAgent
rl_glue = RLGlue(env, agent)
rl_glue.rl_init(agent_info, env_info)
manager = Manager(env_info,
agent_info,
true_values_file=true_values_file,
experiment_name=experiment_name)
for episode in range(1, num_episodes + 1):
rl_glue.rl_episode(0) # no step limit
if episode % plot_freq == 0:
values = rl_glue.agent.agent_message("get_values")
manager.visualize(values, episode)
values = rl_glue.agent.agent_message("get_values")
return values
def start():
# Менеджер файлов
manager = Manager()
print("Добро пожаловать в файловый менеджер!\n"
f"Список доступных команд:\n{Manager.get_formatted_commands()}")
# Начало программы
while True:
command = input("\nFileManager: ").split(" ")
# Выход
if command[0] == "exit":
break
# Получаем команду
res = manager.router(command[0])
if res:
try:
res(*command[1:])
except TypeError:
print(f"Команда {command[0]} была использована некорректно")
else:
print(f"Команды {command[0]} не существует.\n"
f"Список команд:\n{Manager.get_formatted_commands()}")
print("Вы вышли из файлового менеджера.")
def main():
parser = argparse.ArgumentParser()
parser.add_argument("contestants",
help="path to all contestant robot jars")
parser.add_argument("-r",
"--robocode",
help="path to robocode directory",
metavar="PATH")
parser.add_argument("-n", "--name", help="the name of the tournament")
args = parser.parse_args()
if not exists(args.contestants):
print("malformed argument: contestants: " \
+ "the given directory does not exist")
exit()
tournament = "tournament" if args.name is None else args.name
man = Manager(tournament)
if man.get_round(0) is None:
contestants = [
f for f in listdir(args.contestants)
if isfile(join(args.contestants, f)) and f.endswith(".jar")
]
man.make_round(contestants, 4)
print("")
print("[[ROBOCODE BRACKETS]]")
print("")
menu(man)
def finish_job():
if not (request.json):
abort(400)
manager = Manager(request.json)
response = manager.check_job()
return jsonify(response)
def do_job():
if not (request.json):
abort(400)
manager = Manager(request.json)
response = manager.do_job()
return jsonify(response)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-mode', default= 'train', help= '[train/test]')
parser.add_argument('-model', default= 'gcn3d', help= '[pointnet/dgcnn/gcn3d]')
parser.add_argument('-cuda', default= '0', help= 'Cuda index')
parser.add_argument('-epoch', type= int, default= 100, help= 'Epoch number')
parser.add_argument('-lr', type= float, default= 1e-4, help= 'Learning rate')
parser.add_argument('-bs', type= int, default= 1, help= 'Batch size')
parser.add_argument('-dataset', help= "Path to modelnet point cloud data")
parser.add_argument('-load', help= 'Path to load model')
parser.add_argument('-save', help= 'Path to save model')
parser.add_argument('-record', help= 'Record file name (e.g. record.log)')
parser.add_argument('-interval', type= int, default= 200, help= 'Record interval within an epoch')
parser.add_argument('-support', type= int, default= 1, help= 'Support number')
parser.add_argument('-neighbor', type= int, default= 20, help= 'Neighbor number')
parser.add_argument('-normal', dest= 'normal', action= 'store_true', help= 'Normalize objects (zero-mean, unit size)')
parser.set_defaults(normal= False)
parser.add_argument('-shift', type= float, help= 'Shift objects (original: 0.0)')
parser.add_argument('-scale', type= float, help= 'Enlarge/shrink objects (original: 1.0)')
parser.add_argument('-rotate', type= float, help= 'Rotate objects in degree (original: 0.0)')
parser.add_argument('-axis', type= int, default= 2, help= 'Rotation axis [0, 1, 2] (upward = 2)')
parser.add_argument('-random', dest= 'random', action= 'store_true', help= 'Randomly transform in a given range')
parser.set_defaults(random= False)
args = parser.parse_args()
model = GCN3D(support_num= args.support, neighbor_num= args.neighbor)
if args.model == 'pointnet':
model = PointNetCls(40)
elif args.model == 'dgcnn':
model = DGCNN()
manager = Manager(model, args)
transform = Transform(
normal= args.normal,
shift= args.shift,
scale= args.scale,
rotate= args.rotate,
axis= args.axis,
random= args.random
)
if args.mode == "train":
print('Trianing ...')
train_data = ModelNet_pointcloud(args.dataset, 'train', transform= transform)
train_loader = DataLoader(train_data, shuffle= True, batch_size= args.bs)
test_data = ModelNet_pointcloud(args.dataset, 'test', transform= transform)
test_loader = DataLoader(test_data, shuffle= False, batch_size= args.bs)
manager.train(train_loader, test_loader)
else:
print('Testing ...')
test_data = ModelNet_pointcloud(args.dataset, 'test', transform= transform)
test_loader = DataLoader(test_data, shuffle= False, batch_size= args.bs)
test_loss, test_acc = manager.test(test_loader)
print('Test Loss: {:.5f}'.format(test_loss))
print('Test Acc: {:.5f}'.format(test_acc))
def add_card(self, m_input):
m = Manager()
m_input.side_effect = [
"1", "BCIT", "A01029289", "Leeseul Kim", "2020-05-01", ""
]
m.add_card()
return m
