def do_move(self, src, dir):
dest = self.new_loc(src, dir)
if self.orders.has_key(dest):
return False
if src == dest:
self.orders[dest] = src
self.visited_cnt[dest] += 1
self.my_ants[src].visited_cnt[
dest] = 1 + self.my_ants[src].visited_cnt.get(dest, 0)
return True
if self.map_data[dest] & UNPASSABLE:
return False
self.orders[dest] = src
output_str = 'o %s %s %s\n' % (src / self.cols, src % self.cols, dir)
sys.stdout.write(output_str)
sys.stdout.flush()
getLogger().debug(output_str)
for k, v in self.my_hill_distance.iteritems():
v[dest] = self.compute_distance(dest, v)
for k, v in self.hill_rewards.iteritems():
v[dest] = self.compute_qvalue(dest, v)
for i in self.directions:
next_loc = self.new_loc(src, i)
v[next_loc] = self.compute_qvalue(next_loc, v)
for j in self.directions:
next_next_loc = self.new_loc(next_loc, j)
v[next_next_loc] = self.compute_qvalue(next_next_loc, v)
self.visited_cnt[dest] += 1
self.my_ants[src].visited_cnt[
dest] = 1 + self.my_ants[src].visited_cnt.get(dest, 0)
self.my_ants[src].prev_dir = dir
return True
def do_move(self, src, dir):
dest = self.new_loc(src, dir)
if self.orders.has_key(dest):
return False
if src == dest:
self.orders[dest] = src
self.visited_cnt[dest] += 1
self.my_ants[src].visited_cnt[dest] = 1 + self.my_ants[src].visited_cnt.get(dest, 0)
return True
if self.map_data[dest] & UNPASSABLE:
return False
self.orders[dest] = src
output_str = 'o %s %s %s\n' % (src / self.cols, src % self.cols, dir)
sys.stdout.write(output_str)
sys.stdout.flush()
getLogger().debug(output_str)
for k, v in self.my_hill_distance.iteritems():
v[dest] = self.compute_distance(dest, v)
for k, v in self.hill_rewards.iteritems():
v[dest] = self.compute_qvalue(dest, v)
for i in self.directions:
next_loc = self.new_loc(src, i)
v[next_loc] = self.compute_qvalue(next_loc, v)
for j in self.directions:
next_next_loc = self.new_loc(next_loc, j)
v[next_next_loc] = self.compute_qvalue(next_next_loc, v)
self.visited_cnt[dest] += 1
self.my_ants[src].visited_cnt[dest] = 1 + self.my_ants[src].visited_cnt.get(dest, 0)
self.my_ants[src].prev_dir = dir
return True
def update_visible(self):
def _degrees_of_freedom_(loc):
entry_points = []
for d in self.directions:
next_loc = self.new_loc(i, d)
if not self.map_data[next_loc] == WATER:
entry_points.append(next_loc)
return entry_points
self.visible.clear()
for loc in self.my_ants:
ant = self.my_ants[loc]
del ant.visible_milestones[:]
squares = self.get_circular_area(loc, self.viewradius2)
for i in squares:
if self.map_data[i] == UNSEEN:
self.map_data[i] = LAND
if self.milestones.has_key(i):
self.seen_milestones[i] = 1
self.visible[i] = 1
if self.unvisited_milestones.has_key(i):
if self.map_data[i] == WATER:
self.milestones[i] = False
self.unvisited_milestones.pop(i)
else:
entry_points = _degrees_of_freedom_(i)
#if len(entry_points) > 1:
if len(entry_points) > 0:
ant.visible_milestones.append(i)
else:
for entry_point in entry_points:
if len(_degrees_of_freedom_(entry_point)) > 1:
ant.visible_milestones.append(entry_point)
self.unvisited_milestones[
entry_point] = True
ant.curr_milestone = entry_point
self.milestones[entry_point] = True
break
self.milestones[i] = False
self.unvisited_milestones.pop(i)
if ant.curr_milestone == i:
ant.curr_milestone = None
getLogger().debug(
"Ant %s, visible_milestones: %s" %
(self.loc_str(loc),
[self.loc_str(i) for i in ant.visible_milestones]))
def generate_milestones(self):
# Divide the map into smaller (manageable) targets.
# A*/BFS can be applied on the targets for better exploration
viewradius_half = self.viewradius/2
#viewradius_half = self.viewradius
viewradius_quarter = viewradius_half/2
for i in range(0, self.rows/viewradius_half - 1):
midx_partial_sum = self.cols * (i * viewradius_half + viewradius_quarter)
for r in range(i * viewradius_half, (i+1)*viewradius_half):
partial_sum = self.cols * r
for j in range(0, self.cols/viewradius_half - 1):
mid = midx_partial_sum + j * viewradius_half + viewradius_quarter
self.milestones[mid] = 1
for c in range(j * viewradius_half, (j+1) * viewradius_half):
loc = partial_sum + c
self.nearest_milestone[loc] = mid
self.unvisited_milestones = self.milestones.copy()
self.milestone_rewards = dict([(i, {}) for i in self.milestones.keys()])
getLogger().debug("Milestones: " + str([(i/self.cols, i%self.cols) for i in sorted(self.milestones.keys())]))
def update_visible(self):
def _degrees_of_freedom_(loc):
entry_points = []
for d in self.directions:
next_loc = self.new_loc(i, d)
if not self.map_data[next_loc] == WATER:
entry_points.append(next_loc)
return entry_points
self.visible.clear()
for loc in self.my_ants:
ant = self.my_ants[loc]
del ant.visible_milestones[:]
squares = self.get_circular_area(loc, self.viewradius2)
for i in squares:
if self.map_data[i] == UNSEEN:
self.map_data[i] = LAND
if self.milestones.has_key(i):
self.seen_milestones[i] = 1
self.visible[i] = 1
if self.unvisited_milestones.has_key(i):
if self.map_data[i] == WATER:
self.milestones[i] = False
self.unvisited_milestones.pop(i)
else:
entry_points = _degrees_of_freedom_(i)
#if len(entry_points) > 1:
if len(entry_points) > 0:
ant.visible_milestones.append(i)
else:
for entry_point in entry_points:
if len(_degrees_of_freedom_(entry_point)) > 1:
ant.visible_milestones.append(entry_point)
self.unvisited_milestones[entry_point] = True
ant.curr_milestone = entry_point
self.milestones[entry_point] = True
break
self.milestones[i] = False
self.unvisited_milestones.pop(i)
if ant.curr_milestone == i:
ant.curr_milestone = None
getLogger().debug("Ant %s, visible_milestones: %s" % (self.loc_str(loc), [self.loc_str(i) for i in ant.visible_milestones]))
def _chase_milestone_(milestone):
getLogger().debug("Chasing milestone: %s" % self.loc_str(milestone))
ant.curr_milestone = milestone
rewards = {'n' : 0, 'w' : 0, 's' : 0, 'e' : 0}
directions = rewards.keys()
for i in directions:
new_loc = self.new_loc(loc, i)
reward = self.milestone_rewards[milestone].get(new_loc, 0)
for r in self.hill_rewards.values():
if r.has_key(new_loc):
reward += r[new_loc]
break
rewards[i] = reward
directions.sort(key=rewards.get, reverse=True)
getLogger().debug("Explore rewards: %s" % str(rewards))
if rewards[directions[0]] == rewards[directions[-1]]:
return False
self.try_move(loc, directions)
return True
def _chase_milestone_(milestone):
getLogger().debug("Chasing milestone: %s" %
self.loc_str(milestone))
ant.curr_milestone = milestone
rewards = {'n': 0, 'w': 0, 's': 0, 'e': 0}
directions = rewards.keys()
for i in directions:
new_loc = self.new_loc(loc, i)
reward = self.milestone_rewards[milestone].get(new_loc, 0)
for r in self.hill_rewards.values():
if r.has_key(new_loc):
reward += r[new_loc]
break
rewards[i] = reward
directions.sort(key=rewards.get, reverse=True)
getLogger().debug("Explore rewards: %s" % str(rewards))
if rewards[directions[0]] == rewards[directions[-1]]:
return False
self.try_move(loc, directions)
return True
class FileCollector(Collector):
log = mylogger.getLogger(name='filecollector', level=logging.DEBUG)
def collect(self):
c = []
self.log.info('Collecting')
t0 = time.time()
for file in glob.iglob(self.ap.root + '/**/*', recursive=True):
for e in self.ap.extensions:
if file.endswith('.' + e):
c.append(pfile.PFile(file))
self.log.info('Collected %s files in %ss' % (len(c), time.time() - t0))
return c
def test1():
# test PWM functions
print("Initialize logger")
# misc.loggerinit('log/loggingconf.yml')
mylogger.loggerinit('log/loggingconf.yml')
print("Initialize RPi GPIO board mode")
misc.RPiGPIOinit()
print("Begin test %s" % test_subject)
logger = mylogger.getLogger('test')
logger.info("Test of %s start.", test_subject)
# TODO:
# add test-code here.
logger.info("Test of %s end.", test_subject)
print("End test %s" % test_subject)
def generate_milestones(self):
# Divide the map into smaller (manageable) targets.
# A*/BFS can be applied on the targets for better exploration
viewradius_half = self.viewradius / 2
#viewradius_half = self.viewradius
viewradius_quarter = viewradius_half / 2
for i in range(0, self.rows / viewradius_half - 1):
midx_partial_sum = self.cols * (i * viewradius_half +
viewradius_quarter)
for r in range(i * viewradius_half, (i + 1) * viewradius_half):
partial_sum = self.cols * r
for j in range(0, self.cols / viewradius_half - 1):
mid = midx_partial_sum + j * viewradius_half + viewradius_quarter
self.milestones[mid] = 1
for c in range(j * viewradius_half,
(j + 1) * viewradius_half):
loc = partial_sum + c
self.nearest_milestone[loc] = mid
self.unvisited_milestones = self.milestones.copy()
self.milestone_rewards = dict([(i, {})
for i in self.milestones.keys()])
getLogger().debug("Milestones: " +
str([(i / self.cols, i % self.cols)
for i in sorted(self.milestones.keys())]))
def test1():
# test PWM functions
print("Initialize logger")
# misc.loggerinit('log/loggingconf.yml')
mylogger.loggerinit('log/loggingconf.yml')
print("Initialize RPi GPIO board mode")
misc.RPiGPIOinit()
print("Begin test1 of PWM")
logger = mylogger.getLogger('test')
logger.info("PWM test start.")
p = GPIO.PWM(12, 100)
p.start(100)
p.ChangeDutyCycle(0)
p.ChangeFrequency(200)
p.ChangeDutyCycle(100)
p.stop()
logger.info("PWM test end.")
print("Test over")
class ChatServer(object):
LOG = mylogger.getLogger('Server')
HOST = '127.0.0.1'
PORT = 9999
def __init__(self):
self.server_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.usermanager = UserConnManager()
def checkOnlineWithCircle(self, connmanager):
"""每隔10分钟检查用户池用户在线状况"""
user_list = connmanager.getList()
threadlock = threading.RLock()
if len(user_list) != 0:
self.LOG.info('开始检查在线状况')
threadlock.acquire()
for x in user_list:
if x[1].get('isalive') == False:
connmanager.rmfromList(x[0])
threadlock.release()
else:
self.LOG.info('在线用户池为空 跳过此轮检查')
def checkWebResponce(self, addr):
check_info = baseinfo.Info()
check_info.setType('check')
check_info.setMsg('ok')
check_info_dict = baseinfo.info2Dict(check_info)
check_info_byte = json.dumps(check_info_dict).encode('utf-8')
self.server_sock.sendto(check_info_byte, addr)
self.LOG.info('服务端->客户端: %s' % check_info_byte)
def start(self):
self.LOG.debug(self.server_sock)
self.server_sock.bind((self.HOST, self.PORT))
self.LOG.info('服务器绑定地址 %s' % str((ChatServer.HOST, ChatServer.PORT)))
threading.Timer(10 * 60, self.checkOnlineWithCircle,
(self.usermanager, )).start()
self.LOG.info('用户池检查线程开始计时')
self.LOG.info('等待客户端发送信息')
stop_status = False
while not stop_status:
recv_data, recv_addr = self.server_sock.recvfrom(1024)
if recv_data:
jsonstr = recv_data.decode('utf-8')
infodict = json.loads(jsonstr)
info = baseinfo.dict2Info(infodict)
if self.usermanager.isOnline(info.getUid()) == True:
self.usermanager.update2List(info.getUid(), recv_addr)
if info.getType() == 'msg':
self.LOG.info('客户端->服务端: %s' % recv_data)
for x in self.usermanager.getList():
self.LOG.debug('当前用户列表: %s', x)
if self.usermanager.isOnline(info.getRecvUid()) == True:
self.server_sock.sendto(
recv_data,
self.usermanager.getAddr(info.getRecvUid()))
else:
self.LOG.info('用户 %s 不在线' % info.getRecvUid())
####
elif info.getType() == 'check':
self.checkWebResponce(recv_addr)
self.usermanager.add2List(info.getUid(), recv_addr)
elif info.getType() == 'exit':
self.usermanager.rmfromList(info.getUid())
self.LOG.info('客户端 %s 已离线' % info.getUid())
#TODO(feathershine) 未完成服务器控制台指令输入
def cmdStart(self):
def cmd(self):
command = input()
if command == 'quit':
exit()
threading.Thread(target=cmd, args=(self)).start()
self.LOG.info('控制台线程开启')
from mylogger import getLogger
logger = getLogger(__name__)
def hello():
logger.debug("before", position="hello")
_logger = logger.bind(name="foo", age=20)
_logger.info("hello")
logger.debug("after", position="hello")
return "hello"
'''
import keyboard
from PIL import Image
from PIL import ImageTk
from PIL import ImageGrab
import time
import sys
import mylogger
import random
from 文字识别 import BaiDuApi
#from 剪切板 import GetTexts
import os
log = mylogger.getLogger(loglevel='debug', name='keyboard')
def screenShot(path):
#开始截图
if keyboard.wait('alt+ctrl+a') == None:
#截图的结束
if keyboard.wait('enter') == None:
time.sleep(0.01)
log.debug('完成图片的保存')
img = ImageGrab.grabclipboard()
#保存到粘贴板
randomNum = str(random.randrange(100))
#url = path+randomNum+'.png'
#print(url)
img.save(path)
#!/usr/bin/python3
# -*- coding=utf-8 -*-
import keyboard
import mylogger
import os
import time
import win32con
import win32clipboard as w
from PIL import ImageGrab
log = mylogger.getLogger(loglevel='warning', name=__name__)
def screenShot():
if keyboard.wait('alt+ctrl+q') == None:
log.info('start grab')
if keyboard.wait('enter') == None:
time.sleep(1)
im = ImageGrab.grabclipboard()
if (im != None):
log.info('snapshot is finished!')
im.save('snapshot.png')
if __name__ == '__main__':
print()
screenShot()
def explore_milestones(self, loc):
ant = self.my_ants[loc]
def _chase_milestone_(milestone):
getLogger().debug("Chasing milestone: %s" % self.loc_str(milestone))
ant.curr_milestone = milestone
rewards = {'n' : 0, 'w' : 0, 's' : 0, 'e' : 0}
directions = rewards.keys()
for i in directions:
new_loc = self.new_loc(loc, i)
reward = self.milestone_rewards[milestone].get(new_loc, 0)
for r in self.hill_rewards.values():
if r.has_key(new_loc):
reward += r[new_loc]
break
rewards[i] = reward
directions.sort(key=rewards.get, reverse=True)
getLogger().debug("Explore rewards: %s" % str(rewards))
if rewards[directions[0]] == rewards[directions[-1]]:
return False
self.try_move(loc, directions)
return True
def _chase_random_milestone_():
milestones = [i for i in ant.visible_milestones if ((i != ant.last_milestone) and (self.milestones[i]))]
#milestones = [i for i in ant.visible_milestones if (self.milestones[i])]
random.shuffle(milestones)
for milestone in milestones:
if _chase_milestone_(milestone):
return True
return False
getLogger().debug("Explore details for ant %s" % self.loc_str(loc))
getLogger().debug(ant)
for d in self.directions:
new_loc = self.new_loc(loc, d)
if self.milestones.has_key(new_loc):
ant.visited_milestones[new_loc] = True
if new_loc == ant.curr_milestone:
ant.last_milestone = new_loc
ant.curr_milestone = None
if not ant.curr_milestone:
milestones = [i for i in ant.visible_milestones if ((not ant.visited_milestones.has_key(i)) and self.milestones[i])]
#if not milestones:
# milestones = [i for i in ant.visible_milestones if self.milestones[i]]
if not milestones:
#return self.explore(loc)
return _chase_random_milestone_()
milestones.sort(key=lambda x: self.distance_sq(x, loc), reverse=True)
ant.curr_milestone = milestones[-1]
del milestones[-1:]
elif ant.curr_milestone == loc:
# Target achieved! Take up a new target.
getLogger().debug("Target achieved: Need to change milestone")
ant.visited_milestones[loc] = True
milestones = [i for i in ant.visible_milestones if ((i != loc) and (not ant.visited_milestones.has_key(i)) and self.milestones[i])]
ant.last_milestone = loc
#if not milestones:
#milestones = [i for i in ant.visible_milestones if ((i != loc) and self.milestones[i])]
if not milestones:
#return self.explore(loc)
return _chase_random_milestone_()
milestones.sort(key=lambda x: self.distance_sq(x, loc), reverse=True)
ant.curr_milestone = milestones[-1]
del milestones[-1:]
else:
milestones = [i for i in ant.visible_milestones if ((i != loc) and (i != ant.curr_milestone) and (not ant.visited_milestones.has_key(i)) and self.milestones[i])]
milestones.sort(key=lambda x: self.distance_sq(x, loc), reverse=True)
if not _chase_milestone_(ant.curr_milestone):
if not milestones:
if _chase_random_milestone_():
return True
for milestone in milestones:
if _chase_milestone_(milestone):
return True
return False
#return self.explore(loc)
return self.random_explore(loc)
def explore_milestones(self, loc):
ant = self.my_ants[loc]
def _chase_milestone_(milestone):
getLogger().debug("Chasing milestone: %s" %
self.loc_str(milestone))
ant.curr_milestone = milestone
rewards = {'n': 0, 'w': 0, 's': 0, 'e': 0}
directions = rewards.keys()
for i in directions:
new_loc = self.new_loc(loc, i)
reward = self.milestone_rewards[milestone].get(new_loc, 0)
for r in self.hill_rewards.values():
if r.has_key(new_loc):
reward += r[new_loc]
break
rewards[i] = reward
directions.sort(key=rewards.get, reverse=True)
getLogger().debug("Explore rewards: %s" % str(rewards))
if rewards[directions[0]] == rewards[directions[-1]]:
return False
self.try_move(loc, directions)
return True
def _chase_random_milestone_():
milestones = [
i for i in ant.visible_milestones
if ((i != ant.last_milestone) and (self.milestones[i]))
]
#milestones = [i for i in ant.visible_milestones if (self.milestones[i])]
random.shuffle(milestones)
for milestone in milestones:
if _chase_milestone_(milestone):
return True
return False
getLogger().debug("Explore details for ant %s" % self.loc_str(loc))
getLogger().debug(ant)
for d in self.directions:
new_loc = self.new_loc(loc, d)
if self.milestones.has_key(new_loc):
ant.visited_milestones[new_loc] = True
if new_loc == ant.curr_milestone:
ant.last_milestone = new_loc
ant.curr_milestone = None
if not ant.curr_milestone:
milestones = [
i for i in ant.visible_milestones
if ((not ant.visited_milestones.has_key(i))
and self.milestones[i])
]
#if not milestones:
# milestones = [i for i in ant.visible_milestones if self.milestones[i]]
if not milestones:
#return self.explore(loc)
return _chase_random_milestone_()
milestones.sort(key=lambda x: self.distance_sq(x, loc),
reverse=True)
ant.curr_milestone = milestones[-1]
del milestones[-1:]
elif ant.curr_milestone == loc:
# Target achieved! Take up a new target.
getLogger().debug("Target achieved: Need to change milestone")
ant.visited_milestones[loc] = True
milestones = [
i for i in ant.visible_milestones
if ((i != loc) and (not ant.visited_milestones.has_key(i))
and self.milestones[i])
]
ant.last_milestone = loc
#if not milestones:
#milestones = [i for i in ant.visible_milestones if ((i != loc) and self.milestones[i])]
if not milestones:
#return self.explore(loc)
return _chase_random_milestone_()
milestones.sort(key=lambda x: self.distance_sq(x, loc),
reverse=True)
ant.curr_milestone = milestones[-1]
del milestones[-1:]
else:
milestones = [
i for i in ant.visible_milestones
if ((i != loc) and (i != ant.curr_milestone) and (
not ant.visited_milestones.has_key(i))
and self.milestones[i])
]
milestones.sort(key=lambda x: self.distance_sq(x, loc),
reverse=True)
if not _chase_milestone_(ant.curr_milestone):
if not milestones:
if _chase_random_milestone_():
return True
for milestone in milestones:
if _chase_milestone_(milestone):
return True
return False
#return self.explore(loc)
return self.random_explore(loc)
def do_turn(self):
self.food.update(self.new_food)
for loc in self.food.keys():
if self.visible.has_key(loc) and not self.new_food.has_key(loc):
self.food.pop(loc)
self.map_data[loc] = LAND
self.orders.clear()
self.deferred_moves = {}
self.available_ants.update(self.my_ants)
self.update_visible()
for hill in self.my_hills:
if not self.my_hill_distance.has_key(hill):
self.my_hill_distance[hill] = {hill: 0}
for hill in self.enemy_hills[:]:
if self.map_data[hill] != ENEMY_HILL:
self.enemy_hills.remove(hill)
self.map_data[hill] = LAND
self.hill_rewards.pop(hill)
#self.explore_targets = [i for i in self.unvisited_milestones.keys() if self.visible.has_key(i)]
self.explore_targets = [
i for i in self.unvisited_milestones.keys()
if self.seen_milestones.has_key(i)
]
getLogger().debug("Explore targets.........")
getLogger().debug(self.explore_targets)
getLogger().debug("Explore targets: %s" % str(self.explore_targets))
self.update_MDP()
self.defender_cnt = 0
self.watchmen_cnt = 0
explore = self.explore
#explore = self.explore_milestones
self.update_battle_clusters()
if random.randint(0, 99) < 95:
evaluate = self.heuristic_evaluate
else:
evaluate = self.greedy_evaluate
if len(self.my_ants) < 3:
evaluate = self.escape_evaluate
elif len(self.my_hills) < 3:
if 15 < len(self.my_ants) <= 20:
self.watchmen_cnt = 1
if 20 < len(self.my_ants) <= 30:
self.watchmen_cnt = 2
elif 30 < len(self.my_ants) <= 50:
self.watchmen_cnt = 2
self.defender_cnt = 3
elif 50 < len(self.my_ants) <= 100:
self.watchment_cnt = 2
self.defender_cnt = 8
elif 100 < len(self.my_ants) <= 150:
self.defender_cnt = 10
self.watchmen_cnt = 4
elif 150 < len(self.my_ants) <= 200:
self.defender_cnt = 20
self.watchmen_cnt = 4
elif len(self.my_ants) > 200:
self.defender_cnt = 40
self.watchmen_cnt = 4
if len(self.my_ants) > 200:
explore = self.random_explore
self.defend()
warrior_list = sorted(self.my_warriors.keys(),
key=lambda x: len(self.my_warriors[x]))
for ant in warrior_list:
if self.defenders.has_key(ant) or self.watchmen.has_key(ant):
continue
self.fight(ant, 0, evaluate)
for ant in self.available_ants.keys():
if self.gather(ant):
continue
for ant in self.available_ants.keys():
explore(ant)
cnt = 0
changed = True
while changed:
changed = False
for ant in self.deferred_moves.keys():
for d in self.deferred_moves[ant]:
if self.do_move(ant, d):
self.deferred_moves.pop(ant)
changed = True
break
#if cnt >= 10:
#break
cnt += 1
self.deferred_moves.clear()
self.cleanup()
#!/usr/bin/python3
# -*- coding=utf-8 -*-
import mylogger
import myutil
import mygui
import os
#logging.basicConfig(level=logging.DEBUG)
logger = mylogger.getLogger(loglevel='debug', name='test')
logger.debug('test log text')
print('fine!')
print(os.path.abspath('main.py'))
'''
str_test = input()
print('the input str\'s len is', len(str_test))
print('ths str max char is', max(str_test))
print('the str min char is', min(str_test))
print(str(123456))# 将其他数据类型转为字符串
str_test *= 3 #重复字符串
str_test += 'test' #连接字符串
print('now the str is', str_test)
str_list = []
str_list.append(str_test)
print('the list len is', len(str_list))
print('we create 3 random str is',random_str(),random_str(),random_str())
'''
class ChatClient(object):
LOG = mylogger.getLogger('Client')
HOST = '127.0.0.1'
PORT = 9999
ADDR = (HOST, PORT)
def __init__(self):
self.client_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.uid = 'client1'
def checkNet(self):
"""检查网络是否通畅"""
timer = time.time()
self.LOG.info('timer = %s' % timer)
check_info = baseinfo.Info()
check_info.setType('check')
check_info.setUid(self.uid)
check_info_dict = baseinfo.info2Dict(check_info)
check_info_byte = json.dumps(check_info_dict).encode('utf-8')
self.LOG.debug(check_info_byte)
while True:
nowtime = time.time()
self.LOG.info('nowtime = %s' % nowtime)
if nowtime - timer >= 3.0:
return False
self.client_sock.sendto(check_info_byte, self.ADDR)
time.sleep(0.5)
recv_data = self.client_sock.recv(1024)
if recv_data:
check_result_dict = json.loads(recv_data.decode('utf-8'))
check_result = baseinfo.dict2Info(check_result_dict)
if check_result.msg == 'ok':
return True
def waitMsg(self):
while True:
self.LOG.info('等待接受信息')
recv_data = self.client_sock.recv(1024)
if recv_data:
info_dict = json.loads(recv_data.decode('utf-8'))
info = baseinfo.dict2Info(info_dict)
msg = info.getMsg()
senduid = info.getUid()
self.LOG.info('[%s] %s' % (senduid, msg))
def sendMsg(self, senduid, msg):
info = baseinfo.Info()
info.setMsg(msg)
info.setType('msg')
info.setUid(self.uid)
info.setRecvUid(senduid)
info_dict = baseinfo.info2Dict(info)
info_byte = json.dumps(info_dict).encode('utf-8')
self.client_sock.sendto(info_byte, self.ADDR)
def sendLogOutMsg(self):
info = baseinfo.Info()
info.setType('exit')
info.setUid(self.uid)
info_dict = baseinfo.info2Dict(info)
info_byte = json.dumps(info_dict).encode('utf-8')
self.client_sock.sendto(info_byte, self.ADDR)
def start(self):
self.LOG.info('客户端开启')
check_status = self.checkNet()
self.LOG.info('网络验证结果: %s' % check_status)
if check_status == True:
sendto = input()
msg = input()
msg_thread = threading.Thread(target=self.waitMsg, args=(self, ))
if msg == 'quit':
self.sendLogOutMsg()
return
else:
self.sendMsg(sendto, msg)
time.sleep(5)
import glob
import logging
import os
import sys
import time
from datetime import datetime
import mylogger
import pactions
import pcollectors
import pfilters
from pfile import PFile
log = mylogger.getLogger(level=logging.DEBUG)
class Argparser:
collectors = []
actions = []
filters = []
def __init__(self):
self.collection = []
args = sys.argv[1:]
for i, a in enumerate(sys.argv[1:]):
if a == 'from':
self.startDate = args[i + 1]
elif a == 'to':
self.endDate = args[i + 1]
elif os.path.isdir(a):
import logging
import sqlite3
import exif_const
import mylogger
log = mylogger.getLogger(name = 'DB', level = logging.DEBUG)
def createColListForTable():
list = ''
for t in exif_const.tags:
list += ',' + t.replace(' ', '_') + " STRING"
return list
def createColListForValues():
list = ''
for t in exif_const.tags:
list += ',' + t.replace(' ', '_')
return list
def createValuesList(pfile):
list = ''
for t in exif_const.tags:
list += ',"' + str(pfile.getTag(t)) + '"'
return list
class PDB:
SQL_CREATE_EXIF_DATA = 'CREATE TABLE IF NOT EXISTS EXIF_DATA (' +\
'ID INTEGER PRIMARY KEY AUTOINCREMENT,' +\
import utils
import mylogger
LOGGER = mylogger.getLogger(__file__)
def create_launch_specification(region_number, instanceType):
return {
# Region irrelevant fields
'IamInstanceProfile': {
'Name': utils.IAM_INSTANCE_PROFILE
},
'InstanceType':
instanceType,
'UserData':
utils.USER_DATA_BASE64,
# Region relevant fields
'SecurityGroups': [{
# In certain scenarios, we have to use group id instead of group name
# https://github.com/boto/boto/issues/350#issuecomment-27359492
'GroupId':
utils.CONFIG[region_number][utils.REGION_SECURITY_GROUP_ID]
}],
'ImageId':
utils.CONFIG[region_number][utils.REGION_AMI],
'KeyName':
utils.CONFIG[region_number][utils.REGION_KEY],
'TagSpecifications': [{
'ResourceType':
'instance',
'Tags': [{
def do_turn(self):
self.food.update(self.new_food)
for loc in self.food.keys():
if self.visible.has_key(loc) and not self.new_food.has_key(loc):
self.food.pop(loc)
self.map_data[loc] = LAND
self.orders.clear()
self.deferred_moves = {}
self.available_ants.update(self.my_ants)
self.update_visible()
for hill in self.my_hills:
if not self.my_hill_distance.has_key(hill):
self.my_hill_distance[hill] = {hill : 0}
for hill in self.enemy_hills[:]:
if self.map_data[hill] != ENEMY_HILL:
self.enemy_hills.remove(hill)
self.map_data[hill] = LAND
self.hill_rewards.pop(hill)
#self.explore_targets = [i for i in self.unvisited_milestones.keys() if self.visible.has_key(i)]
self.explore_targets = [i for i in self.unvisited_milestones.keys() if self.seen_milestones.has_key(i)]
getLogger().debug("Explore targets.........")
getLogger().debug(self.explore_targets)
getLogger().debug("Explore targets: %s" % str(self.explore_targets))
self.update_MDP()
self.defender_cnt = 0
self.watchmen_cnt = 0
explore = self.explore
#explore = self.explore_milestones
self.update_battle_clusters()
if random.randint(0, 99) < 95:
evaluate = self.heuristic_evaluate
else:
evaluate = self.greedy_evaluate
if len(self.my_ants) < 3:
evaluate = self.escape_evaluate
elif len(self.my_hills) < 3:
if 15 < len(self.my_ants) <= 20:
self.watchmen_cnt = 1
if 20 < len(self.my_ants) <= 30:
self.watchmen_cnt = 2
elif 30 < len(self.my_ants) <= 50:
self.watchmen_cnt = 2
self.defender_cnt = 3
elif 50 < len(self.my_ants) <= 100:
self.watchment_cnt = 2
self.defender_cnt = 8
elif 100 < len(self.my_ants) <= 150:
self.defender_cnt = 10
self.watchmen_cnt = 4
elif 150 < len(self.my_ants) <= 200:
self.defender_cnt = 20
self.watchmen_cnt = 4
elif len(self.my_ants) > 200:
self.defender_cnt = 40
self.watchmen_cnt = 4
if len(self.my_ants) > 200:
explore = self.random_explore
self.defend()
warrior_list = sorted(self.my_warriors.keys(), key=lambda x: len(self.my_warriors[x]))
for ant in warrior_list:
if self.defenders.has_key(ant) or self.watchmen.has_key(ant):
continue
self.fight(ant, 0, evaluate)
for ant in self.available_ants.keys():
if self.gather(ant):
continue
for ant in self.available_ants.keys():
explore(ant)
cnt = 0
changed = True
while changed:
changed = False
for ant in self.deferred_moves.keys():
for d in self.deferred_moves[ant]:
if self.do_move(ant, d):
self.deferred_moves.pop(ant)
changed = True
break
#if cnt >= 10:
#break
cnt += 1
self.deferred_moves.clear()
self.cleanup()
