def save(self, path) -> Status:
header = create_svg_header(self._display_dimensions)
content = header + self._commands + '</svg>\n'
status = Status(ok=True)
try:
with open(path, 'w') as svg_file:
svg_file.write(content)
except Exception as e:
err_str = 'Error writing to {}: {}.'.format(path, str(e))
status = Status(ok=False, err_str=err_str)
return status
def __init__(self, host, timeout, full_scan, gauge, output_window):
threading.Thread.__init__(self)
#pull the wx frame for the info box event
self.output_window = output_window
#creat messanger object for sending text to panel
self.message = PanelMessage(output_window)
#get gauge instance from gui
self.gauge = gauge
#get host
self.host = host
#boolean to indicate if the scan will do all ports or the smaller set
self.full_scan = full_scan
#queue to pass ports to threads
self.queue = Queue.Queue()
#empty array that will hold the list of open ports
self.port_list = []
#counter to caluclate ports scasnned per second
self.count = 0
#passed to threads, how long to wait on port response
self.timeout = timeout
#how many threads to run concurently
self.threadcount = 200
#list to contain all the threeads generated
self.threads = []
#range of ports to scan, set 9999 as default, but changed later if needed
self.portrange = 9999
#list of common ports for the shart scan
self.common_ports = [
20, 21, 22, 23, 79, 80, 110, 113, 119, 143, 443, 1002, 1720, 5000,
8080
]
#start Status object, pass actule number of ports to be scanned
#change some variables depending on the type of scan chosen
if self.full_scan == True:
self.status = Status(self.portrange - 1, self.output_window)
else:
self.portrange = len(self.common_ports)
self.status = Status(self.portrange, self.output_window)
self.threadcount = self.portrange
def __init__(self):
self.config = Config()
#self.client = pylxd.Client(endpoint=self.config['DEFAULT']['LXD_URL'], cert=(self.config['DEFAULT']['LXD_CERT'], self.config['DEFAULT']['LXD_KEY']), verify=False)
self.client = pylxd.Client()
#client.authenticate('ferrari')
self.status = Status()
def __init__(self):
self._time_manager = TimeManager()
self._params = Params()
self._status = Status(self._params)
self.log_time = time.time()
self._pwm_read = PwmRead(
self._params.pin_mode_in,
self._params.pin_servo_in,
self._params.pin_thruster_in,
self._params.pin_or,
)
self._pwm_out = PwmOut(self._params.pin_servo_out,
self._params.pin_thruster_out)
self._pid = PositionalPID()
self._logger = Logger()
self._logger.open()
# Whether experienced OR mode or not
self._or_experienced = False
# setup for ina226
print("Configuring INA226..")
try:
self.i_sensor = ina226(INA226_ADDRESS, 1)
self.i_sensor.configure(
avg=ina226_averages_t["INA226_AVERAGES_4"], )
self.i_sensor.calibrate(rShuntValue=0.002, iMaxExcepted=1)
self.i_sensor.log()
print("Mode is " + str(hex(self.i_sensor.getMode())))
except:
print("Error when configuring INA226")
time.sleep(1)
print("Configuration Done")
def Main():
d1 = datetime.datetime.now()
lonelyMan = RenRenSpider()
lonelyMan.login()
userID = lonelyMan.getUserID()
checkPaths(userID)
checkPaths(ownerID=config.ownerID)
albumList = AlbumList(userID, lonelyMan, ownerID=config.ownerID)
albumList.work()
status = Status(userID, lonelyMan, config.ownerID)
status.work()
bloglist = BlogList(userID, lonelyMan, config.ownerID)
bloglist.work()
gossip = Gossip(userID, lonelyMan, config.ownerID)
gossip.work()
repo = RepoMysql(userID, lonelyMan)
repo.work()
d2 = datetime.datetime.now()
print 'all have been done, time: ', d2 - d1
def __init__(self):
self.state = State(0)
self.params = Params()
self.status = Status(self.params)
self.sleep_time = 1
self.pwm_read = PwmRead(
self.params.pin_mode_in,
self.params.pin_servo_in,
self.params.pin_thruster_in,
self.params.pin_OR,
)
self.pwm_out = PwmOut(self.params.pin_servo_out, self.params.pin_thruster_out)
self.pid = PositionalPID()
self.logger = Logger()
self.logger.open()
# Whether experienced OR mode or not
self.or_experienced = False
# setup for ina226
print("Configuring INA226..")
self.iSensor = ina226(INA226_ADDRESS, 1)
self.iSensor.configure(
avg=ina226_averages_t["INA226_AVERAGES_4"],
)
self.iSensor.calibrate(rShuntValue=0.002, iMaxExcepted=1)
time.sleep(1)
print("Configuration Done")
current = self.iSensor.readShuntCurrent()
print("Current Value is " + str(current) + "A")
print("Mode is " + str(hex(self.iSensor.getMode())))
def update_contacts(self):
self._contacts = [
DummyContact(
self, 'Echo', 'echo',
'http://beanies.vn/wp-content/uploads/2014/05/belgian_waffle-1513470.jpg',
Status(0, 'I will repeat your every message <3'))
]
return True
def __init__(self):
self.state = State(0)
self.params = Params()
self.status = Status(self.params)
self.sleep_time = 1
self.pwm_read = PwmRead(self.params.pin_mode_in, self.params.pin_servo_in, self.params.pin_thruster_in)
self.pwm_out = PwmOut(self.params.pin_servo_out, self.params.pin_thruster_out)
self.pid = PositionalPID()
self.logger = Logger()
self.logger.open()
def open(self, pab, devname):
logger.info("open %s", devname)
if mode(pab) == INPUT:
if dataType(pab) == DISPLAY:
if recordLength(pab) == 0 or recordLength(pab) == 80:
self.tipi_io.send([SUCCESS])
self.tipi_io.send([80])
self.tipiStatus = Status()
self.recordNo = 0
return
self.tipi_io.send([EOPATTR])
def __init__(self, columns, rows, max_iterations, alphabet, threshold_proportion, mutator_name):
self.columns = columns
self.rows = rows
self.max_iterations = max_iterations
self.alphabet = alphabet
self.status = Status(max_iterations, rows, columns, len(alphabet))
self.dataset = Dataset(rows= rows, cols = columns, alphabet=alphabet)
self.data = self.dataset.get_data()
if mutator_name == 'RandomFlip':
self.mutator = RandomFlip(self.dataset, 0.3)
elif mutator_name == 'Exponential':
self.mutator = ExpMutator(self.dataset, 0.3)
def __init__(self):
self.config = Config()
self.metaQ = Queue('pluto',
connection=Redis('windows', 6379, db=1),
default_timeout=1 * 3600)
self.status = Status()
client = pymongo.MongoClient(
f"mongodb+srv://explorer:{self.config.MongoPass}@cluster0-eyzcm.mongodb.net/test?retryWrites=true&w=majority"
)
self.db = client.plutoQ
self.cm = ContainerManager()
def getPosts(user,clean=True,maxPosts=100):
try:
userName = user.facebookId
args = {}
graph = GraphAPI(at)
profile = graph.get_object(userName)
posts = graph.get_connections(profile['id'], 'posts', **args)
statuses = []
lastUntil = ''
for s in posts['paging']['next'].split('&'):
if 'limit=' in s:
args['limit'] = s.split('=')[1]
if 'until=' in s:
args['until'] = s.split('=')[1]
while True:
isBreak = False
for data in posts['data']:
if 'message' not in data:
continue
smessage = str(data['message'].encode("utf-8")).replace('\\n', ' ').replace('\\r', '')[2:-1]
if clean:
smessage = re.sub(r'https?:\/\/[^\s]*','',smessage, flags=re.MULTILINE)
smessage = re.sub(r'\\x..','',smessage, flags=re.MULTILINE)
smessage = re.sub(r'&','and',smessage, flags=re.IGNORECASE)
smessage = re.sub(r'[\s\t]+',' ',smessage, flags=re.IGNORECASE)
smessage.replace('#','')
if validPost(smessage):
st = Status()
st.statusText = smessage
st.id = data['id']
statuses.append(st)
if len(statuses) > maxPosts:
break
posts = graph.get_connections(profile['id'], 'posts',**args)
nargs = {}
for s in posts['paging']['next'].split('&'):
if 'limit=' in s:
nargs['limit'] = s.split('=')[1]
if 'until=' in s:
nargs['until'] = s.split('=')[1]
if nargs['until'] == args['until']:
break
else:
args['limit'] = nargs['limit']
args['until'] = nargs['until']
return statuses
except ConnectionError:
return []
def Put(self, write_options, key, value):
assert isinstance(write_options, WriteOptions)
assert isinstance(key, six.binary_type)
assert isinstance(value, six.binary_type)
status = Status()
rocksdb_put(
self.dbptr_internal,
write_options.to_rocksdb_internal(),
key, len(key),
value, len(value),
ctypes.byref(status.to_rocksdb_internal()))
return status
def Open(db_options, dbname):
assert isinstance(db_options, DBOptions)
assert isinstance(dbname, six.binary_type)
status = Status()
dbptr = rocksdb_open(
db_options.to_rocksdb_internal(),
dbname,
ctypes.byref(status.to_rocksdb_internal()))
if dbptr:
return DB(dbptr), status
else:
return None, status
def __init__(self, security=None, status=Status(), ctaTemplate=None, controlRisk=None,
enableTrade=False, enableBuy=True, enableShort=True, frequency=None,
pricePosi_top = 0, pricePosi_bottom = 4,
jqDataAccount='13268108673', jqDataPassword='******'):
futureMsg = fm.getFutureMsg(security)
self.enableTrade = enableTrade
self.enableBuy = enableBuy
self.enableShort = enableShort
self.ctaTemplate = ctaTemplate
self.controlRisk = controlRisk
self.status = status
self.jqDataAccount = jqDataAccount
self.jqDataPassword = jqDataPassword
self.frequency = frequency
self.dataRow = 100
self.pricePosi_top = pricePosi_top
self.pricePosi_bottom = pricePosi_bottom
self.lastExeTime = None
self.security = security
self.pricePositions = []
self.maxPosition = dao.readMaxPosition(security)
self.duo_position = dao.readDuoPosition(security) # 多单持仓手数
self.kong_position = dao.readKongPosition(security) # 空单持仓手数
self.writeCtaLog('########################允许交易：' + str(self.enableTrade))
self.writeCtaLog('########################开多：' + str(self.enableBuy))
self.writeCtaLog('########################开空：' + str(self.enableShort))
self.writeCtaLog('########################合约代码：' + str(self.security))
self.writeCtaLog('########################多单持仓：' + str(self.duo_position))
self.writeCtaLog('########################空单持仓：' + str(self.kong_position))
self.writeCtaLog('########################最大持仓：' + str(self.maxPosition))
self.writeCtaLog('########################策略级别：' + str(self.frequency))
self.writeCtaLog('########################jqdata账号：' + str(self.jqDataAccount))
self.dayStartTime = futureMsg['dayStartTime']
self.dayEndTime = futureMsg['dayEndTime']
self.noonStartTime = futureMsg['noonStartTime']
self.noonEndTime = futureMsg['noonEndTime']
self.afternoonStartTime = futureMsg['afternoonStartTime']
self.afternoonEndTime = futureMsg['afternoonEndTime']
try :
self.nightStartTime = futureMsg['nightStartTime']
self.nightEndTime = futureMsg['nightEndTime']
except:
self.nightStartTime = None
self.nightEndTime = None
self.isInit = True
self.rate = 1
self.openPrice = None
def dijkstra(graph, time_diff):
'''
Calculates the shortest path from a starting node to any other node in a given graph
using the Dijkstra algorithm and taking into account time tables.
:param int graph.n_vertices: The number of nodes in the graph
:param dict graph.edges: A dictionary with the form {(edge_start, edge_end): edge_weight}
:param dict graph.neighbors: A dictionary with the form {node: [adjacent_nodes]}
:param int graph.origin: The starting node in the graph
'''
if (graph.neighbors.get(graph.origin) is None):
return [graph.origin], {graph.origin: 0}
status = Status(graph)
computeOriginNode(graph, status, time_diff)
while status.priority_queue:
computeNextNode(graph, status, time_diff)
return status.parents, status.weights
def run(size):
status = Status(size, [[0 for x in range(size)] for y in range(size)])
queen = Queen(size)
i = 1
check_set = 0
while True:
check_set = queen.set_queen(status)
if check_set == size:
"""print the combination, set queen postion value is y-dir value
queen number decremented and go back to previous status as normal"""
status.return_comb()
status.stat_arr[queen.pos_y][queen.pos_x] = queen.pos_y
queen.number -= 1
status.back_status(queen)
elif check_set > 0:
queen.move_queen(status)
else:
status.back_status(queen)
def work(userID, lonelyMan, i):
checkPaths(ownerID=config.ownerID[i])
albumList = AlbumList(userID, lonelyMan, ownerID=config.ownerID[i])
albumList.work()
status = Status(userID, lonelyMan, config.ownerID[i])
status.work()
bloglist = BlogList(userID, lonelyMan, config.ownerID[i])
bloglist.work()
gossip = Gossip(userID, lonelyMan, config.ownerID[i])
gossip.work()
repo = RepoMysql(userID, lonelyMan)
repo.work()
def computegtmod(filename, weighted):
fnetwork = 0
#with open(filename+'_ml_network.pickle') as handle:
# fnetwork = pickle.load(handle)
ml_network, layer, node_l, node_c, top, bot, couple, edge_l, edge_c, mu, commu = read_raw_network(
filename, weighted)
status = Status()
status.layer = layer
status.node_l = node_l
status.node_c = node_c
status.top = top
status.bot = bot
status.edge_l = edge_l
status.edge_c = edge_c
status.couple = couple
status.mu = mu
mod = __modularity(commu, status, ml_network)
return mod, commu
def Get(self, read_options, key):
assert isinstance(read_options, ReadOptions)
assert isinstance(key, six.binary_type)
status = Status()
vallen = ctypes.c_size_t()
valptr = rocksdb_get(
self.dbptr_internal,
read_options.to_rocksdb_internal(),
key, len(key),
ctypes.byref(vallen),
ctypes.byref(status.to_rocksdb_internal()))
if not status.OK or not valptr:
return None, status
else:
vt = ctypes.c_char * (vallen.value)
res = ctypes.cast(valptr, ctypes.POINTER(vt))
return res.contents.value, status
def getTweets(user,clean=True,includeRetweets=False,maxTweets=1000000,includeOtherMentions=True):
twitter_access_token_key,twitter_access_token_secret,twitter_consumer_key,twitter_consumer_secret = Config.getTwitterKeys()
api = TwitterAPI(twitter_access_token_key,twitter_access_token_secret, twitter_consumer_key, twitter_consumer_secret)
tweets = []
li = api.fetch_by_user_names(user.twitterId,clean = clean)
while li is not None and len(li) > 0:
if "errors" in li and li["errors"][0]["code"] == 88:
return []
for tweet in li:
tweetText = str(tweet['text'].encode("utf-8")).replace('\\n', ' ').replace('\\r', '').strip()[2:-1]
if not includeRetweets and tweetText.startswith('RT'):
continue
if not includeOtherMentions and "@" in tweet['text']:
continue
if clean:
tweetText = re.sub(r'https?:\/\/[^\s]*','',tweetText, flags=re.MULTILINE)
tweetText = re.sub(r'\\x..','',tweetText, flags=re.MULTILINE)
tweetText = re.sub(r'&','and',tweetText, flags=re.IGNORECASE)
tweetText = re.sub(r'[\s\t]+',' ',tweetText, flags=re.IGNORECASE)
tweetText.replace('#','')
tweetText = re.sub('^\s*rt\s',' ',tweetText,flags=re.IGNORECASE)
if not validTweet(tweetText):
continue
st = Status()
st.id = tweet['id']
st.likes = tweet['favorite_count']
st.shares = tweet['retweet_count']
st.CreatedOn = tweet['created_at']
st.statusType = 1
st.statusText = tweetText
st.language = tweet["lang"]
tweets.append(st)
minId = min(tweets,key=lambda p:p.id).id
li = api.fetch_by_user_names(user.twitterId,id= minId - 1,clean = clean)
if len(tweets) > maxTweets or li is None or len(li) < 10:
break
return tweets
def opprett_statuser(self): #Oppretter status-objekter
try:
status_info_string = self.hent_JSON("https://gbfs.urbansharing.com/oslobysykkel.no/station_status.json")
updated_at = status_info_string['last_updated']
statuser = status_info_string['data']['stations']
except:
self.funnet_feil("Kunne ikke opprette statuser. ")
return
if not statuser:
funnet_feil("Ingen stasjoner funnet. ")
return
alle_statuser = []
for status in statuser:
try:
ny_status = Status(updated_at, status['station_id'], status['is_installed'],
+ status['is_renting'], status['num_bikes_available'],
+ status['num_docks_available'], status['last_reported'], status['is_returning'])
alle_statuser.append(ny_status)
except:
self.funnet_feil("Feil ved opprettelse av status. ")
return alle_statuser
class _Game:
__WIDTH = 64
__HEIGHT = 24
__NPLAYER = 6
__normalWaitTime = 0
__eventWaitTime = 0
__eventTurn = False
__nTurn = 0
DEBUGMODE = False
teamA = TeamA()
teamB = TeamB()
__score_a = 0
__score_b = 0
players = []
playerOfTeamA = []
playerOfTeamB = []
ball = None
ballOwner = None
__screen = [[]]
__statusA = Status()
__statusB = Status()
__orderA = Order()
__orderB = Order()
delay_time = 0
# public _Game() {
# this(1000, 500);
# }
def __init__(self, normalWaitTime=None, eventWaitTime=None):
self.__normalWaitTime = normalWaitTime
self.__eventWaitTime = eventWaitTime
def run(self):
self.initialize(0)
#self.updateScr()
self.__printScr()
self.delay(self.delay_time)
while True:
self.__nTurn += 1
self.clearScr()
self.onetick()
self.applyOrder(self.__orderA, self.__orderB)
self.__printScr()
goalCheck = self.__goalCheck()
if goalCheck == 1:
self.__eventTurn = True
self.initialize(2)
elif goalCheck == 2:
self.__eventTurn = True
self.initialize(1)
if self.endCheck() == 1:
print("endgame")
if self.__score_a > self.__score_b: return 1
elif self.__score_b > self.__score_a: return 2
else: return 0
if self.__eventTurn:
self.delay(self.delay_time * 5)
self.__eventTurn = False
else:
self.delay(self.delay_time)
def initialize(self, starter):
self.__screen = [[None for _ in range(self.__HEIGHT)]
for _ in range(self.__WIDTH)]
self.playerOfTeamA = [None] * 6
self.playerOfTeamA[0] = Player(0, ((self.__WIDTH - 1) / 2) - 25,
self.__HEIGHT / 2 - 4, 30, 30, 40)
self.playerOfTeamA[1] = Player(1, ((self.__WIDTH - 1) / 2) - 24,
self.__HEIGHT / 2 - 2, 25, 40, 50)
self.playerOfTeamA[2] = Player(2, ((self.__WIDTH - 1) / 2) - 23,
self.__HEIGHT / 2, 20, 50, 35)
self.playerOfTeamA[3] = Player(3, ((self.__WIDTH - 1) / 2) - 24,
self.__HEIGHT / 2 + 2, 25, 40, 50)
self.playerOfTeamA[4] = Player(4, ((self.__WIDTH - 1) / 2) - 25,
self.__HEIGHT / 2 + 4, 30, 30, 40)
self.playerOfTeamA[5] = Player(5, ((self.__WIDTH - 1) / 2) - 28,
self.__HEIGHT / 2, 50, 50, 55)
self.playerOfTeamB = [None] * 6
self.playerOfTeamB[0] = Player(6, ((self.__WIDTH - 1) / 2) + 26,
self.__HEIGHT / 2 - 4, 30, 30, 40)
self.playerOfTeamB[1] = Player(7, ((self.__WIDTH - 1) / 2) + 25,
self.__HEIGHT / 2 - 2, 25, 40, 50)
self.playerOfTeamB[2] = Player(8, ((self.__WIDTH - 1) / 2) + 24,
self.__HEIGHT / 2, 20, 50, 35)
self.playerOfTeamB[3] = Player(9, ((self.__WIDTH - 1) / 2) + 25,
self.__HEIGHT / 2 + 2, 25, 40, 50)
self.playerOfTeamB[4] = Player(10, ((self.__WIDTH - 1) / 2) + 26,
self.__HEIGHT / 2 + 4, 30, 30, 40)
self.playerOfTeamB[5] = Player(11, ((self.__WIDTH - 1) / 2) + 29,
self.__HEIGHT / 2, 50, 50, 55)
self.players = [None] * 12
for i in range(12):
if i < 6: self.players[i] = self.playerOfTeamA[i]
else: self.players[i] = self.playerOfTeamB[i - 6]
if starter == 0:
self.__score_a = 0
self.__score_b = 0
self.__nTurn = 0
if self.__throwCointWithProbability(50):
self.ball = Ball(self.playerOfTeamA[2].x,
self.playerOfTeamA[2].y)
self.ballOwner = self.playerOfTeamA[2]
self.playerOfTeamA[2].getBall(self.ball)
else:
self.ball = Ball(self.playerOfTeamB[2].x,
self.playerOfTeamB[2].y)
self.ballOwner = self.playerOfTeamB[2]
self.playerOfTeamB[2].getBall(self.ball)
elif starter == 1:
self.ball = Ball(self.playerOfTeamA[2].x, self.playerOfTeamA[2].y)
self.ballOwner = self.playerOfTeamA[2]
self.playerOfTeamA[2].getBall(self.ball)
elif starter == 2:
self.ball = Ball(self.playerOfTeamB[2].x, self.playerOfTeamB[2].y)
self.ballOwner = self.playerOfTeamB[2]
self.playerOfTeamB[2].getBall(self.ball)
for p in self.players:
self.__screen[int(p.x)][int(p.y)] = p
def onetick(self):
ballOwner = -1 if self.ballOwner == None else self.ballOwner.getId()
self.__statusA.setStatus(self.generateUnitInfo(False), ballOwner,
self.__nTurn)
self.teamA.execute(self.__statusA, self.__orderA)
ballOwnerForB = 0
if ballOwner == -1: ballOwnerForB = -1
elif ballOwner < 6: ballOwnerForB = ballOwner + 6
else: ballOwnerForB = ballOwner - 6
self.__statusB.setStatus(self.generateUnitInfo(False), ballOwnerForB,
self.__nTurn)
self.teamB.execute(self.__statusB, self.__orderB)
# // debug
# // for (int i = 0; i < 6; i++) {
# // System.out.println((char) ('a' + i) + ":(" + orderA.dx[i] + "," +
# // orderA.dy[i] + ")\t" + (char) ('1' + i)
# // + ":(" + orderB.dx[i] + "," + orderB.dy[i] + ")");
# // }
def generateUnitInfo(self, mirror):
result = [None] * 13
#teamB
if mirror:
result[0] = Unit(self.ball, True)
for i in range(1, 13):
if i <= 6: result[i] = Unit(self.playerOfTeamB[i - 1], True)
else: result[i] = Unit(self.playerOfTeamA[i - 7], True)
#teamA
else:
result[0] = Unit(self.ball)
for i in range(1, 13):
if i <= 6: result[i] = Unit(self.playerOfTeamA[i - 1])
else: result[i] = Unit(self.playerOfTeamB[i - 7])
return result
#main process
def applyOrder(self, oa, obr):
ob = Order(obr, True)
#move하기 전에 좌표를 none처리 필요해보임 edit**************
for p in self.playerOfTeamA:
p.move(oa.dx[p.getNumber()], oa.dy[p.getNumber()])
self.__screen[int(p.x)][int(p.y)] = p
# if oa.dx[p.getNumber()]!=0 or oa.dy[p.getNumber()]!=0:
# self.__screen[int(p.x)][int(p.y)]=None
# p.move(oa.dx[p.getNumber()],oa.dy[p.getNumber()])
# self.__screen[int(p.x)][int(p.y)] = p
for p in self.playerOfTeamB:
p.move(ob.dx[p.getNumber()], ob.dy[p.getNumber()])
self.__screen[int(p.x)][int(p.y)] = p
# if ob.dx[p.getNumber()]!=0 or ob.dy[p.getNumber()]!=0:
# self.__screen[int(p.x)][int(p.y)]=None
# p.move(ob.dx[p.getNumber()], ob.dy[p.getNumber()])
# self.__screen[int(p.x)][int(p.y)] = p
self.__contendCheck()
self.__passCheck()
self.__ballCheck()
def __contendCheck(self):
for i in range(self.__NPLAYER * 2):
contendingPlayers = []
for j in range(i + 1, self.__NPLAYER * 2):
if self.players[i].isSamePositionWith(self.players[j]):
contendingPlayers.append(self.players[j])
if len(contendingPlayers) >= 1:
contendingPlayers.append(self.players[i])
self.contend(contendingPlayers)
def contend(self, players):
rlength = 0
winner = -1
for p in players:
rlength += p.getStrength()
if rlength == 0: winner = self.getRandom(0, len(players) - 1)
else:
r = self.getRandom(0, rlength - 1)
rm = rM = 0
for i in range(len(players)):
rM += players[i].getStrength()
if r >= rm and r < rM:
winner = i
break
rm = rM
wx = int(players[winner].x)
wy = int(players[winner].y)
for i in range(len(players)):
if i == winner:
players[i].winContending()
self.__screen[wx][wy] = players[i]
#공 날라감
#공이 날라가는 좌표는 None이 아니여도 된다 수정 필요해보임*******************, ball.fly2함수 필요해보임 **
else:
if players[i].isBallOwner():
ix = wx + self.getRandom(-3, 3)
iy = wy + self.getRandom(-3, 3)
while (ix < 0 or ix >= self.__WIDTH or iy < 0
or iy >= self.__HEIGHT) or (
self.__screen[int(ix)][int(iy)] != None):
ix = wx + self.getRandom(-3, 3)
iy = wy + self.getRandom(-3, 3)
# self.ball.fly2(ix, iy)
self.ballOwner = None
ix = int(wx + self.getRandom(-3, 3))
iy = int(wy + self.getRandom(-3, 3))
count = 0
while (ix < 0 or ix >= self.__WIDTH or iy < 0
or iy >= self.__HEIGHT) or (
self.__screen[int(ix)][int(iy)] != None):
count += 1
ix = int(wx + self.getRandom(-3, 3))
iy = int(wy + self.getRandom(-3, 3))
self.__screen[int(ix)][int(iy)] = players[i]
if self.DEBUGMODE:
print(f' player {i} is intend to go to {ix}, {iy}')
#apply stamina, set position, ballowner false
players[i].loseContending(ix, iy)
def __passCheck(self):
if self.ballOwner != None:
passtarget = None
if (
self.ballOwner.getId() >= 0 and self.ballOwner.getId() < 6
) and self.__orderA.passto >= 0 and self.ballOwner != self.playerOfTeamA[
self.__orderA.passto]:
passtarget = self.playerOfTeamA[self.__orderA.passto]
elif (
self.ballOwner.getId() >= 6 and self.ballOwner.getId() < 12
) and self.__orderB.passto >= 0 and self.ballOwner != self.playerOfTeamB[
self.__orderB.passto]:
passtarget = self.playerOfTeamB[self.__orderB.passto]
else:
return
if self.DEBUGMODE:
print(
f' pass from {self.ballOwner.getId()} to {passtarget.getId()} '
)
#같은 x선 좌표에 있을경우
m = n = 0
if self.ballOwner.getX() == passtarget.getX():
yV = int((passtarget.getY() - self.ballOwner.getY()) /
abs(passtarget.getY() - self.ballOwner.getY()))
i = int(self.ballOwner.getY())
while i != passtarget.getY() - yV:
i += yV
if (self.__screen[self.ballOwner.getX()][i] != None):
#intercepted by screen[ballOwner.x][i]
print("intercepted!!!")
self.ballOwner.throwBall()
interceptPlayer = self.__screen[
self.ballOwner.getX()][i]
interceptPlayer.getBall(self.ball)
self.ballOwner = interceptPlayer
return
# ballowner의 y좌표가 passtarget의 y좌표가 작을 경우만 고려되어있음 수정필요 (**********************)
# for i in range(self.ballOwner.getY()+ yV, passtarget.getY()-yV,yV):
# if self.__screen[self.ballOwner.getX()][i]!=None:
# print('intercepted')
# self.ballOwner.throwBall()
# interceptPlayer= self.__screen[self.ballOwner.getX()][i]
# interceptPlayer.getBall(self.ball)
# self.ballOwner=interceptPlayer
# return
# ?? Ballowner가 passtarget보다 큰 경우가 있어 수정이 필요
#대각선 혹은 y좌표가 같을경우
else:
m = (self.ballOwner.getY() - passtarget.getY()) / (
self.ballOwner.getX() - passtarget.getX())
n = self.ballOwner.getY() - m * self.ballOwner.getX()
xV = int((passtarget.getX() - self.ballOwner.getX()) /
abs(passtarget.getX() - self.ballOwner.getX()))
i = self.ballOwner.getX() + xV
while i != passtarget.getX():
i += xV
fi = int(m * i + n + 0.4)
if self.__screen[int(i)][int(fi)] != None:
print("intercepted!!!")
self.ballOwner.throwBall()
interceptPlayer = self.__screen[int(i)][int(fi)]
interceptPlayer.getBall(self.ball)
self.ballOwner = interceptPlayer
return
#인터셉트 안당했을 경우 거리에 따라 다른 확률 적용
d = self.ballOwner.getDistance(passtarget)
if d > 5:
r = self.getRandom(0, self.ballOwner.getPass() + d * 5 - 1)
if r < self.ballOwner.getPass():
self.ballOwner.throwBall()
passtarget.getBall(self.ball)
self.ballOwner = passtarget
else:
self.ballOwner.throwBall()
ix = passtarget.getX() + self.getRandom(-2, 2)
iy = passtarget.getY() + self.getRandom(-2, 2)
while (ix == passtarget.getX() and iy == passtarget.getY()
) or (ix < 0 or ix >= self.__WIDTH or iy < 0
or iy >= self.__HEIGHT):
ix = passtarget.getX() + self.getRandom(-2, 2)
iy = passtarget.getY() + self.getRandom(-2, 2)
self.ball.fly2(ix, iy)
self.ballOwner = None
else:
self.ballOwner.throwBall()
passtarget.getBall(self.ball)
self.ballOwner = passtarget
def __ballCheck(self):
if self.ballOwner != None: self.ball.dribbled(self.ballOwner)
else:
if self.__screen[self.ball.getX()][self.ball.getY()] != None:
self.ballOwner = self.__screen[self.ball.getX()][
self.ball.getY()]
self.ballOwner.getBall(self.ball)
def getRandom(self, m, n):
d = int(abs(m - n) + 1)
return int(random() * d) + m
def __throwCointWithProbability(self, probability):
if probability < 0 or probability > 100:
print('probability error')
return False
r = int(random() * 100)
if r < probability: return True
else: return False
def __printScr(self):
# if self.ballOwner==None: self.__screen[int(self.ball.x)][int(self.ball.y)]=self.ball
print(f' Score {self.__score_a}: {self.__score_b} ')
print(f' Turn: {self.__nTurn}')
print(
'%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%'
)
for i in range(self.__HEIGHT):
print_list = list()
if i < self.__HEIGHT / 2 - 5 or i >= self.__HEIGHT / 2 + 5:
print('%', end='')
else:
print(" ", end='')
for j in range(self.__WIDTH):
if self.__screen[j][i] == None: print_list.append(" ")
else:
if self.__screen[j][i].getId(
) >= 0 and self.__screen[j][i].getId() < 6:
print_list.append(
chr(ord('a') + self.__screen[j][i].getNumber()))
elif self.__screen[j][i].getId(
) >= 6 and self.__screen[j][i].getId() < 12:
print_list.append(
str(1 + self.__screen[j][i].getNumber()))
print("".join(print_list), end='')
if i < self.__HEIGHT / 2 - 5 or i >= self.__HEIGHT / 2 + 5:
print('%')
else:
print(" ")
print(
'%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%'
)
os.system('cls')
def clearScr(self):
# line=5
# if self.DEBUGMODE==False: line+=10
# for i in range(line):
# print(" ")
# print("\033[H\033[2J")
os.system('cls')
sys.stdout.flush()
self.__screen = [[None for _ in range(self.__HEIGHT)]
for _ in range(self.__WIDTH)]
def __goalCheck(self):
if self.ballOwner != None:
if self.ballOwner.getId() >= 0 and self.ballOwner.getId() < 6:
if self.ballOwner.getX() == self.__WIDTH - 1 and (
self.ballOwner.getY() >= self.__HEIGHT / 2 - 5
and self.ballOwner.getY() < self.__HEIGHT / 2 + 5):
self.__score_a += 1
return 1
elif self.ballOwner.getId() >= 6 and self.ballOwner.getId() < 12:
if self.ballOwner.getX() == 0 and (
self.ballOwner.getY() >= self.__HEIGHT / 2 - 5
and self.ballOwner.getY() < self.__HEIGHT / 2 + 5):
self.__score_b += 1
return 2
return -1
def endCheck(self):
if self.__nTurn >= 1000: return 1
else: return 0
def delay(self, n):
try:
time.sleep(n)
except:
traceback.print_exc()
class Game:
__WIDTH = 64
__HEIGHT = 24
__NPLAYER = 6
__normalWaitTime = 0
__eventWaitTime = 0
__eventTurn = False
__nTurn = 0
DEBUGMODE = False
teamA = TeamA()
teamB = TeamB()
__score_a = 0
__score_b = 0
players = []
playerOfTeamA = []
playerOfTeamB = []
ball = None
ballOwner = None
__screen = [[]]
__statusA = Status()
__statusB = Status()
__orderA = Order()
__orderB = Order()
delay_time = 0
# public _Game() {
# this(1000, 500);
# }
def __init__(self, normalWaitTime, eventWaitTime):
self.__normalWaitTime = normalWaitTime
self.__eventWaitTime = eventWaitTime
self.__eventTurn = False
self.__nTurn = 0
self.teamA = TeamA()
self.teamB = TeamB()
self.__score_a = 0
self.__score_b = 0
def run(self):
self.__initialize(0)
self.__printScr()
self.__delay(self.delay_time)
while True:
self.__nTurn += 1
self.clearScr()
self.onetick()
self.__applyOrder(self.__orderA, self.__orderB)
self.__printScr()
goalCheck = self.goalCheck()
if goalCheck == 1:
self.__eventTurn = True
self.__initialize(2)
elif goalCheck == 2:
self.__eventTurn = True
self.__initialize(1)
if self.__endCheck() == 1:
print("end game")
if self.__score_a > self.__score_b: return 1
elif self.__score_b > self.__score_a: return 2
else: return 0
if self.__eventTurn:
self.__delay(self.delay_time * 5)
self.__eventTurn = False
else:
self.__delay(self.delay_time)
def __initialize(self, starter):
self.__screen = [[None for _ in range(self.__HEIGHT)]
for _ in range(self.__WIDTH)]
self.playerOfTeamA = [0] * 6
self.playerOfTeamA[0] = Player(0, ((self.__WIDTH - 1) / 2) - 25,
self.__HEIGHT / 2 - 4, 30, 30, 40)
self.playerOfTeamA[1] = Player(1, ((self.__WIDTH - 1) / 2) - 24,
self.__HEIGHT / 2 - 2, 25, 40, 50)
self.playerOfTeamA[2] = Player(2, ((self.__WIDTH - 1) / 2) - 23,
self.__HEIGHT / 2, 20, 50, 35)
self.playerOfTeamA[3] = Player(3, ((self.__WIDTH - 1) / 2) - 24,
self.__HEIGHT / 2 + 2, 25, 40, 50)
self.playerOfTeamA[4] = Player(4, ((self.__WIDTH - 1) / 2) - 25,
self.__HEIGHT / 2 + 4, 30, 30, 40)
self.playerOfTeamA[5] = Player(5, ((self.__WIDTH - 1) / 2) - 28,
self.__HEIGHT / 2, 50, 50, 55)
self.playerOfTeamB = [0] * 6
self.playerOfTeamB[0] = Player(6, ((self.__WIDTH - 1) / 2) + 26,
self.__HEIGHT / 2 - 4, 30, 30, 40)
self.playerOfTeamB[1] = Player(7, ((self.__WIDTH - 1) / 2) + 25,
self.__HEIGHT / 2 - 2, 25, 40, 50)
self.playerOfTeamB[2] = Player(8, ((self.__WIDTH - 1) / 2) + 24,
self.__HEIGHT / 2, 20, 50, 35)
self.playerOfTeamB[3] = Player(9, ((self.__WIDTH - 1) / 2) + 25,
self.__HEIGHT / 2 + 2, 25, 40, 50)
self.playerOfTeamB[4] = Player(10, ((self.__WIDTH - 1) / 2) + 26,
self.__HEIGHT / 2 + 4, 30, 30, 40)
self.playerOfTeamB[5] = Player(11, ((self.__WIDTH - 1) / 2) + 29,
self.__HEIGHT / 2, 50, 50, 55)
self.players = [0] * 12
for i in range(len(self.players)):
if i < 6: self.players[i] = self.playerOfTeamA[i]
else: self.players[i] = self.playerOfTeamB[i - 6]
if starter == 0:
self.__score_a = 0
self.__score_b = 0
self.__nTurn = 0
if self.__throwCoinWithProbability(50):
self.ball = Ball(self.playerOfTeamA[2].x,
self.playerOfTeamA[2].y)
self.ballOwner = self.playerOfTeamA[2]
self.playerOfTeamA[2].getBall(self.ball)
else:
self.ball = Ball(self.playerOfTeamB[2].x,
self.playerOfTeamB[2].y)
self.ballOwner = self.playerOfTeamB[2]
self.playerOfTeamB[2].getBall(self.ball)
elif starter == 1:
self.ball = Ball(self.playerOfTeamA[2].x, self.playerOfTeamA[2].y)
self.ballOwner = self.playerOfTeamA[2]
self.playerOfTeamA[2].getBall(self.ball)
elif starter == 2:
self.ball = Ball(self.playerOfTeamB[2].x, self.playerOfTeamB[2].y)
self.ballOwner = self.playerOfTeamB[2]
self.playerOfTeamB[2].getBall(self.ball)
for p in self.players:
self.__screen[int(p.x)][int(p.y)] = p
def onetick(self):
ballOwner = -1 if self.ballOwner == None else self.ballOwner.getId()
self.__statusA.setStatus(self.__generateUnitInfo(False), ballOwner,
self.__nTurn)
self.teamA.execute(self.__statusA, self.__orderA)
ballOwnerForB = 0
if ballOwner == -1: ballOwnerForB = -1
elif ballOwner < 6: ballOwnerForB = ballOwner + 6
else: ballOwnerForB = ballOwner - 6
self.__statusB.setStatus(self.__generateUnitInfo(False), ballOwnerForB,
self.__nTurn)
self.teamB.execute(self.__statusB, self.__orderB)
def __generateUnitInfo(self, mirror):
result = [0] * 13
if mirror:
result[0] = Unit(self.ball, True)
for i in range(1, 13):
if i <= 6: result[i] = Unit(self.playerOfTeamB[i - 1], True)
else: result[i] = Unit(self.playerOfTeamA[i - 7], True)
else:
result[0] = Unit(self.ball)
for i in range(1, 13):
if i <= 6: result[i] = Unit(self.playerOfTeamA[i - 1])
else: result[i] = Unit(self.playerOfTeamB[i - 7])
return result
def __applyOrder(self, oa, obr):
ob = Order(obr, True)
for p in self.playerOfTeamA:
p.move(oa.dx[p.getNumber()], oa.dy[p.getNumber()])
self.__screen[int(p.x)][int(p.y)] = p
for p in self.playerOfTeamB:
p.move(ob.dx[p.getNumber()], ob.dy[p.getNumber()])
self.__screen[int(p.x)][int(p.y)] = p
self.__contendCheck()
self.__passCheck()
self.__ballCheck()
def __contendCheck(self):
for i in range(self.__NPLAYER * 2):
contendingPlayers = []
for j in range(i + 1, self.__NPLAYER * 2):
if self.players[i].isSamePositionWith(self.players[j]):
contendingPlayers.append(self.players[j])
if len(contendingPlayers) >= 1:
contendingPlayers.append(self.players[i])
self.__contend(contendingPlayers)
def __contend(self, players):
rlength = 0
winner = -1
for p in players:
rlength += p.getStrength()
if rlength == 0:
winner = self.getRandom(0, len(players) - 1)
else:
r = self.getRandom(0, rlength - 1)
rm = rM = 0
for i in range(len(players)):
rM += players[i].getStrength()
if r >= rm and r < rM:
winner = i
break
rm = rM
wx = int(players[winner].x)
wy = int(players[winner].y)
for i in range(len(players)):
if i == winner:
players[i].winContending()
self.__screen[wx][wy] = self.players[i]
else:
if players[i].isBallOwner():
ix = wx + self.getRandom(-3, 3)
iy = wy + self.getRandom(-3, 3)
#screen!=none이여야 하나? ^^^^^^^^^^^^^^^^^^^^
while (ix < 0 or ix >= self.__WIDTH or iy < 0
or iy >= self.__HEIGHT
) or self.__screen[int(ix)][int(iy)] != None:
print("a")
ix = wx + self.getRandom(-3, 3)
iy = wy + self.getRandom(-3, 3)
self.ball.fly2(ix, iy)
self.ballOwner = None
ix = int(wx + self.getRandom(-3, 3))
iy = int(wy + self.getRandom(-3, 3))
count = 0
while (ix < 0 or ix >= self.__WIDTH or iy < 0
or iy >= self.__HEIGHT) or (
self.__screen[int(ix)][int(iy)] != None):
count += 1
ix = int(wx + self.getRandom(-3, 3))
iy = int(wy + self.getRandom(-3, 3))
self.__screen[int(ix)][int(iy)] = players[i]
def __passCheck(self):
if self.ballOwner != None:
passtarget = None
if (
self.ballOwner.getId() >= 0 and self.ballOwner.getId() < 6
) and self.__orderA.passto >= 0 and self.ballOwner != self.playerOfTeamA[
self.__orderA.passto]:
passtarget = self.playerOfTeamA[self.__orderA.passto]
elif (
self.ballOwner.getId() >= 6 and self.ballOwner.getId() < 12
) and self.__orderB.passto >= 0 and self.ballOwner != self.playerOfTeamB[
self.__orderB.passto]:
passtarget = self.playerOfTeamB[self.__orderB.passto]
else:
return
m = n = 0
if self.ballOwner.getX() == passtarget.getX():
yV = int((passtarget.getY() - self.ballOwner.getY()) /
abs(passtarget.getY() - self.ballOwner.getY()))
for i in range(self.ballOwner.getY(),
passtarget.getY() - yV, yV):
if self.__screen[int(
self.ballOwner.getX())][int(i)] != None:
print("intercepted")
self.ballOwner.throwBall()
interceptPlayer = self.__screen[int(
self.ballOwner.getX())][int(i)]
interceptPlayer.getBall(self.ball)
self.ballOwner = interceptPlayer
return
else:
m = (self.ballOwner.getY() - passtarget.getY()) / (
self.ballOwner.getX() - passtarget.getX())
n = self.ballOwner.getY() - m * self.ballOwner.getX()
xV = int((passtarget.getX() - self.ballOwner.getX()) /
abs(passtarget.getX() - self.ballOwner.getX()))
i = int(self.ballOwner.getX() + xV)
while i != passtarget.getX():
i += xV
fi = int(m * i + n + 0.4)
if self.__screen[int(i)][int(fi)] != None:
print("intercepted")
self.ballOwner.throwBall()
interceptPlayer = self.__screen[int(i)][int(fi)]
interceptPlayer.getBall(self.ball)
self.ballOwner = interceptPlayer
return
d = int(self.ballOwner.getDistance(passtarget))
if d > 5:
r = self.getRandom(0, self.ballOwner.getPass() + d * 5 - 1)
if r < self.ballOwner.getPass():
self.ballOwner.throwBall()
passtarget.getBall(self.ball)
self.ballOwner = passtarget
#공이 날라갔을 경우
else:
self.ballOwner.throwBall()
ix = passtarget.getX() + self.getRandom(-2, 2)
iy = passtarget.getY() + self.getRandom(-2, 2)
while (ix < 0 or ix > self.__WIDTH or iy < 0 or
iy >= self.__HEIGHT) or (ix == passtarget.getX() and
iy == passtarget.getY()):
ix = passtarget.getX() + self.getRandom(-2, 2)
iy = passtarget.getY() + self.getRandom(-2, 2)
self.ball.fly2(ix, iy)
self.ballOwner = None
#pass 성공된 경우
else:
self.ballOwner.throwBall()
passtarget.getBall(self.ball)
self.ballOwner = passtarget
def __ballCheck(self):
if self.ballOwner != None:
self.ball.dribbled(self.ballOwner)
else:
if self.__screen[self.ball.getX()][self.ball.getY()] != None:
self.ballOwner = self.__screen[self.ball.getX()][
self.ball.getY()]
self.ballOwner.getBall(self.ball)
def getRandom(self, m, n):
return int(random.randint(m, n))
def __throwCoinWithProbability(self, probability):
if probability < 0 or probability > 100:
print("probability error")
return False
r = int(random.random() * 100)
if r < probability: return True
else: return False
def __printScr(self):
# if self.ballOwner==None: self.__screen[self.ball.x][self.ball.y]=self.ball
print(f'Score: {self.__score_a} : {self.__score_b} ')
print(f' Turn: {self.__nTurn}')
print(
'%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%'
)
for i in range(self.__HEIGHT):
print_list = list()
if i < self.__HEIGHT / 2 - 5 or i >= self.__HEIGHT / 2 + 5:
print('%', end='')
else:
print(" ", end='')
for j in range(self.__WIDTH):
if self.__screen[j][i] == None: print_list.append(" ")
else:
if self.__screen[j][i].getId(
) >= 0 and self.__screen[j][i].getId() < 6:
print_list.append(
chr(ord('a') + self.__screen[j][i].getNumber()))
elif self.__screen[j][i].getId(
) >= 6 and self.__screen[j][i].getId() < 12:
print_list.append(
str(1 + self.__screen[j][i].getNumber()))
print("".join(print_list), end='')
if i < self.__HEIGHT / 2 - 5 or i >= self.__HEIGHT / 2 + 5:
print('%')
else:
print(" ")
print(
'%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%'
)
os.system('cls')
def clearScr(self):
# System.out.println("\033[H\033[2J");
# System.out.flush();
self.__screen = [[None for _ in range(self.__HEIGHT)]
for _ in range(self.__WIDTH)]
sys.stdout.flush()
def goalCheck(self):
if self.ballOwner != None:
if self.ballOwner.getId() >= 0 and self.ballOwner.getId() < 6:
if self.ballOwner.getX(
) == self.__WIDTH - 1 and self.ballOwner.getY(
) >= self.__HEIGHT / 2 - 5 and self.ballOwner.getY(
) < self.__HEIGHT / 2 + 5:
self.__score_a += 1
return 1
elif self.ballOwner.getId() >= 6 and self.ballOwner.getId() < 12:
if self.ballOwner.getX() == 0 and (
self.ballOwner.getY() >= self.__HEIGHT / 2 - 5
and self.ballOwner.getY() < self.__HEIGHT / 2 + 5):
self.__score_b += 1
return 2
return -1
def __endCheck(self):
if self.__nTurn < 1000: return 0
elif self.__nTurn == 1000: return 1
def __delay(self, n):
try:
time.sleep(n)
except:
traceback.print_exc()
def run_script(self, script_id):
""" Runs script on this Server. """
href = self.href + "/run_script"
params = {'right_script': script_id}
response, content = self.rsapi.request(href, params, method="POST")
return Status(response.get('location'), self.rsapi)
def __init__(self, client):
self.client = client
self._contacts = []
self.send_status(Status())
self.update_contacts()
def __init__(self,
data,
chunk_size,
hosts,
niceness,
slave_script,
show_output=0,
result=None,
redistribute=1,
verbose=1):
"""
@param data: dict of items to be proessed {id:object}.
@type data: dict
@param chunk_size: number of items that are processed by a job
@type chunk_size: int
@param hosts: list of host-names
@type hosts: [str]
@param niceness: nice dictionary [host-name: niceness]
@type niceness: dict
@param slave_script: absolute path to slave-script
@type slave_script: str
@param result: items which have already been processed
(ie. they are contained in result) are not
processed again.
@type result: dict
@param redistribute: at the end, send same job out several times
(default: 1)
@type redistribute: 1|0
@param verbose: verbosity level (default: 1)
@type verbose: 1|0
"""
PVMMasterSlave.__init__(self, verbose=verbose)
## change names of multiple hosts
d = {}
for host in hosts:
if host in d:
d[host] += 1
else:
d[host] = 1
unique_list = []
for host, number in d.items():
if number > 1:
for i in range(number):
nickname = host + '_%d' % i
d = {'host': host, 'nickname': nickname}
unique_list.append(d)
else:
d = {'host': host, 'nickname': host}
unique_list.append(d)
exe = ExeConfigCache.get('xterm')
exe.validate()
self.xterm_bin = exe.bin
self.hosts = unique_list
self.niceness = niceness
self.data = data
self.slave_script = slave_script
self.chunk_size = chunk_size
self.current_pos = 0
self.show_output = show_output
self.verbose = verbose
if result is None:
result = {}
self.result = result
## set-up status for results
items = []
for key in data.keys():
if not key in self.result:
items.append(key)
self.status = Status(items, redistribute=redistribute)
self.__finished = 0
if verbose: print 'Processing %d items ...' % len(items)
)
zombie_slums.reset()
## Default Theme Reset
default = Default('Default Theme', 'Default', 'Default', 'Default')
default.set_theme()
## Prints the user_map_name
if args.user_map_name:
print(args.user_map_name + "added to our directory")
if args.list:
list = List()
list.print_list()
if args.status:
status = Status()
status.display_status()
if args.arg_mod == 'ugx_mod_1_0_4':
ugx = Ugx104('UGX Mod 1.0.4', 'http://www.ugx-mods.com',
'http://ugx-mods.com/forum/index.php?topic=537.0')
ugx.install()
elif args.arg_mod == 'waw_modtools':
wawmodtools = WawModtools('WaW Modtools',
'http://www.callofduty.gamefront.com/',
'http://callofduty.filefront.com/file/;95890')
wawmodtools.install()
elif args.arg_mod == 'black_ops_perks':
blackopsperks = BlackopsPerks(
def getSeries(filename, weighted):
'''network_name = "networks_low_couple/" + filename.split('/')[-1]
# commented code block
fp=open(network_name,'r')
line=fp.readline()
line=line.rstrip()
n_layer=int(line)
layer={}
node_l={}
l_ID=1
edge_l={}
edge_c={}
# f_el = open(filename+'_edges_list_commod'+str(g), 'w')
for i in range(0,n_layer):
line=fp.readline()
line=line.rstrip()
line=line.split()
layer[l_ID]=set()
##print line
for n in line:
layer[l_ID].add(int(n))
line=fp.readline()
line=int(line.rstrip())
n_edge=line
##print n_edge
edge_l[l_ID]=n_edge
for j in range(0,n_edge):
line=fp.readline()
line=line.rstrip()
line=line.split()
n1=int(line[0])
n2=int(line[1])
if n1 not in node_l:
node_l[n1]=set()
node_l[n1].add(n2)
if n2 not in node_l:
node_l[n2]=set()
node_l[n2].add(n1)
# f_el.write(str(n1-1)+' '+str(n2-1)+'\n')
l_ID+=1
line=fp.readline()
line=line.rstrip()
n_couple=int(line)
##print n_couple
node_c={}
top={}
bot={}
c_ID=1
couple={}
for i in range(0,n_couple):
line=fp.readline()
##print line
line=line.rstrip()
line=line.split()
top[c_ID]=int(line[0])
bot[c_ID]=int(line[1])
couple[c_ID]=layer[top[c_ID]].union(layer[bot[c_ID]])
line=fp.readline()
line=int(line.rstrip())
n_edge=line
##print n_edge
edge_c[c_ID]=n_edge
count_edge = 0
for j in range(0,n_edge):
line=fp.readline()
line=line.rstrip()
line=line.split()
n1=int(line[0])
n2=int(line[1])
if n1 not in node_c:
node_c[n1]=set()
node_c[n1].add(n2)
if n2 not in node_c:
node_c[n2]=set()
node_c[n2].add(n1)
count_edge += 1
# f_el.write(str(n1-1)+' '+str(n2-1)+'\n')
edge_c[c_ID] = count_edge
c_ID=c_ID+1
line=fp.readline()
line=line.rstrip()
##print line
n_comm=int(line)
commu={}
com_ID=1
for i in range(0,n_comm):
line=fp.readline()
line=line.rstrip()
line=line.split()
commu[com_ID]=set()
for n in line:
commu[com_ID].add(int(n))
com_ID+=1
mu=0'''
#with open(filename+'_ml_network.pickle') as handle:
# fnetwork = pickle.load(handle)
ml_network, layer, node_l, node_c, top, bot, couple, edge_l, edge_c, mu, commu = read_raw_network(
filename, weighted)
#ml_network =build_network(layer, node_l, node_c, top, bot, couple, edge_l, edge_c)
#with open(filename+'_ml_network.pickle', 'w') as handle:
# pickle.dump([ml_network, layer, node_l, node_c, top, bot, couple, edge_l, edge_c, mu, commu], handle)
dendogram, mod = louvain(ml_network, layer, node_l, node_c, top, bot,
couple, edge_l, edge_c, mu)
status = Status()
status.layer = layer
status.node_l = node_l
status.node_c = node_c
status.top = top
status.bot = bot
status.edge_l = edge_l
status.edge_c = edge_c
status.couple = couple
status.mu = mu
mod_old = mod
commu = _get_com_wise_nodes(
partition_at_level(dendogram,
len(dendogram) - 1))
#commu =_get_commu_dict(partition_at_level(dendogram, len(dendogram)-1))
mod = __modularity(commu, status, ml_network)
#print "--------- BEF RET ---------"
#print mod_old, mod
#print "----------------"
return mod, dendogram
def louvain(graph, layer, node_l, node_c, top, bot, couple, edge_l, edge_c,
mu):
current_graph = graph.copy()
status = Status()
status.layer = layer
status.node_l = node_l
status.node_c = node_c
status.top = top
status.bot = bot
status.edge_l = edge_l
status.edge_c = edge_c
status.couple = couple
status.mu = mu
status.init(current_graph)
old_status = status.copy()
status_list = list()
level_count = 0
mod = __modularity(_get_commu_dict(status.node2com), status, graph)
#print "Modularity before First Iteration ",mod
__one_level(graph, old_status, current_graph, status, status_list,
level_count)
partition = __renumber(status.node2com)
status_list.append(partition)
current_graph, part, status = induced_graph_multilayer(
partition, current_graph, status)
mod1 = __modularity(_get_com_wise_nodes(part), status, current_graph)
p = _get_com_wise_nodes(
partition_at_level(status_list,
len(status_list) - 1))
new_mod = __modularity(p, old_status, graph)
#print "-> merge mod after level 0 : ", mod1
#print "-> Modularity after level 0: ",new_mod, "\n"
##print("Louvain, partition: ",partition)
#print("Louvain partition: ",part)
A = nx.adjacency_matrix(current_graph)
##print(A.todense())
status.init(current_graph)
while True:
level_count += 1
##print level_count
modif = __one_level(graph, old_status, current_graph, status,
status_list, level_count, 1)
partition = __renumber(status.node2com)
status_list.append(partition)
new_mod = __modularity(
_get_commu_dict(partition_at_level(status_list, level_count)),
old_status, graph)
#print "-> Modularity after level ",level_count,": ",new_mod, "\n"
#new_mod = __modularity(_get_commu_dict(partition), status, current_graph)
#new_mod = __modularity(_get_com_wise_nodes(partition), status, current_graph)
if modif == False:
#if new_mod - mod < __MIN :
break
mod = new_mod
#current_graph = induced_graph(partition, current_graph)
current_graph, part, status = induced_graph_multilayer(
partition, current_graph, status)
#status.init(current_graph)
status.init(current_graph, part)
##print("Louvain, partition: ",partition)
# #print("Louvain, part after: ",part)
# A = nx.adjacency_matrix(current_graph)
##print(A.todense())
return status_list, mod
