def generateDB(request):
message = ""
try:
g = General()
url = "http://10.1.5.42/webandapp/newLocalDB.php"
jsonURL = urllib.request.urlopen(url)
data = json.loads(jsonURL.read().decode())
id = []
names = []
images = []
for d in data:
for k, v in d.items():
#print (v)
if k == 'p_ID':
id.append(v)
if k == 'p_Name':
names.append(v)
if k == 'p_Images':
images.append('faces/' + v)
print(id)
print(names, images)
#print(type(data))
g.generateLocalDB(names, g.encodeImages(images), id)
message = "Successfully generating local DB"
except IOError:
message = 'An error occured trying to read the file.'
except ImportError:
message = "NO file found"
except EOFError:
message = "Why did you do an EOF on me?"
except:
message = 'An error occured.'
return HttpResponse(message)
def Lancement3(nb):
#Création d'un objet PhotoImage pour reconnaître les .git et .png
can1 = Canvas(fenetre, width=900, height=600) #Création du canvas
item = can1.create_image(
0, 0, anchor=NW, image=image3) #Création de l'image de fond du canvas
can1.pack(side='top')
gen = General(can1, fenetre)
gen.Level1(nb, 3)
def __init__(self, username=None, password=None):
self.general = General(self)
self.model = Model(self)
self.actions = Actions(self)
self.groups = Groups(self)
self.customers = Customers(self)
self.segments = Segments(self)
self.integrations = Integrations(self)
if username and password:
self.general.login(username, password)
def test1(strategy_file_path) -> None:
'''
For testing purposes
'''
n_decks = 6
shoe = General.get_shoe(n_decks)
def get_shoe_len() -> int:
'returns the length of the shoe'
return len(shoe)
counter = Counter(strategy_file_path)
counter.set_get_shoe_len(get_shoe_len)
# burn a card
_ = shoe.pop()
for _ in range(20):
# player is dealt the first card
card = shoe.pop()
counter.observe_card(card)
player_hand = [card]
# dealer gets the second card face down
dealer_hand = [shoe.pop()]
# player gets the third card
card = shoe.pop()
counter.observe_card(card)
player_hand.append(card)
# dealer gets the last card face up
upcard = shoe.pop()
counter.observe_card(upcard)
dealer_hand.append(upcard)
print()
print('dealer hand: "{0}"'.format(
General.hand_to_face_string(dealer_hand)))
print('upcard: "{0}"'.format(General.get_face_symbol(upcard)))
print('player hand:', General.hand_to_face_string(player_hand))
print('true: {0:.1f}'.format(counter.get_true()))
# if the up-card is an ace then see if the player requests
# insurance
if counter.requests_insurance(player_hand, upcard):
print('player requests insurance')
else:
print('player declines insurance')
def __init__(self):
#gtk.VBox.__init__(self, False)
#self.set_border_width(10)
gtk.ScrolledWindow.__init__(self)
self.settings_list = []
#scroll = gtk.ScrolledWindow()
self.set_shadow_type(gtk.SHADOW_NONE)
self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
general = General()
proxy = Proxy()
self.settings_list.append(general)
self.settings_list.append(proxy)
vbox1 = gtk.VBox(False, 10)
vbox1.set_border_width(10)
vbox1.pack_start(general, False, False)
vbox1.pack_start(proxy, False, False)
view_port = gtk.Viewport()
view_port.set_shadow_type(gtk.SHADOW_NONE)
view_port.add(vbox1)
self.add(view_port)
def _card_to_index(card: CARD) -> int:
'''
returns index into decision tables. The the
return value must be in the range 0 .. 9
'''
face = General.face_index(card)
return Counter._face_to_index[face]
def __init__(self,
username=None,
password=None,
timeout=TIMEOUT,
url=DEFAULT_URL):
self.general = General(self)
self.model = Model(self)
self.actions = Actions(self)
self.groups = Groups(self)
self.customers = Customers(self)
self.segments = Segments(self)
self.integrations = Integrations(self)
self.timeout = timeout
self._url = url
if username and password:
self.general.login(username, password)
def __init__(self, username=None, password=None, timeout=TIMEOUT, url=DEFAULT_URL):
self.general = General(self)
self.model = Model(self)
self.actions = Actions(self)
self.groups = Groups(self)
self.customers = Customers(self)
self.segments = Segments(self)
self.integrations = Integrations(self)
self.timeout = timeout
self._url = url
if username and password:
self.general.login(username, password)
def main():
#read inputs from file
with open('input.json') as f:
inputs = json.load(f)
for test in inputs:
m = test["m"] #number of traitors
general_objs = test["G"]
generals = []
for g in general_objs:
key = g.keys()[0]
generals.append(General(int(key), g[key]))
#for performance comparison
#generals.append(SeqGeneral(int(key), g[key]))
Oc = ATTACK if test["Oc"] == "ATTACK" else RETREAT
run_test(m, generals, Oc)
def __init__(self, parent=None):
QScrollArea.__init__(self)
self.setWidgetResizable(True)
self.setEnabled(True)
self.widgets = []
self.vbox = QVBoxLayout()
#self.setContentsMargins(0, 0, 0, 0)
self.vbox.setSpacing(5)
self.vbox_widget = QWidget()
self.vbox_widget.setLayout(self.vbox)
self.setWidget(self.vbox_widget)
self.general = General()
self.vbox.addWidget(self.general)
self.widgets.append(self.general)
self.vbox.addStretch(0)
def requests_stand(self, hand: HAND, upcard: CARD) -> bool:
'''
The dealer is asking the player if the hand should stand
i.e. no more cards are to be added
'''
hand_value, is_soft = General.bj_value(hand)
if is_soft:
table_key = 'soft_stand'
else:
table_key = 'hard_stand'
table = self.ddict[table_key]
key = str(hand_value)
true_count = self.get_true()
index = self._card_to_index(upcard)
try:
alist = table[key]
critical_true = alist[index]
return true_count >= critical_true
except KeyError:
return False
import discord
import requests_cache
from discord.ext import commands
from dotenv import load_dotenv
from general import General
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
load_dotenv()
requests_cache.install_cache('cache')
bot = commands.Bot(command_prefix="!", description="Some basic COC utilities", case_insensitive=True)
@bot.event
async def on_ready():
logger.info(f'{bot.user} has connected to Discord!')
await bot.change_presence(status=discord.Status.online, activity=discord.Activity(
name="Clash Of Clans",
type=discord.ActivityType.playing,
start=datetime.datetime.utcnow()
))
if __name__ == '__main__':
bot.add_cog(General(os.getenv('COC_TOKEN')))
logger.info(f"Starting COC BOT at {datetime.datetime.today().strftime('%d-%b-%Y %I:%M %p')}")
bot.run(os.getenv('DISCORD_TOKEN'))
def __init__(self, browser, config):
super(Research, self).__init__(browser, config)
self.general_client = General(browser, config)
def observe_card(self, card: CARD) -> None:
'''
The newly dealt card is shown to the player
'''
self.count += General.get_count_value(card)
class Buildings(Scraper):
def __init__(self, browser, config):
super(Buildings, self).__init__(browser, config)
self.general_client = General(browser, config)
@staticmethod
def parse_buildings(buildings):
planet_buildings = {}
count = 0
for building_type in BuildingTypes:
planet_buildings[building_type] = BuildingItem(buildings[count][0], buildings[count][1])
count += 1
return planet_buildings
def get_buildings(self, planet):
self.logger.info('Getting buildings data for planet %s' % planet.name)
url = self.url_provider.get_page_url('resources', planet)
res = self.open_url(url)
soup = BeautifulSoup(res.read(), "lxml")
building_buttons = soup(attrs={'class': "detail_button"})
buildings = []
for building_button in building_buttons:
building_data = self.get_building_data_from_button(building_button)
if building_data is not None:
buildings.append(building_data)
return buildings
@staticmethod
def get_building_data_from_button(building_button):
""" Read the building data from the building button """
building_id = building_button['ref']
building_data = BUILDINGS_DATA.get(building_id)
# ensures that execution will not break if there is a new item
if building_data is not None:
try:
building_info = "".join(building_button.find("span", {"class": "level"})
.findAll(text=True, recursive=False)[1])
# If we get an exception here it means the building is in construction mode, so we
# the info we need will be at index 0
except IndexError:
building_info = "".join(building_button.find("span", {"class": "level"})
.findAll(text=True, recursive=False)[0])
level = int(re.sub("[^0-9]", "", building_info))
return ItemAction(BuildingItem(building_data.id, building_data.name), level)
else:
return None
def get_weaker_planet(self, planets=None):
if planets is None:
planets = self.general_client.get_planets()
planet_sum_buildings = []
totals = []
for planet in planets:
buildings_sum = sum([bld.amount for bld in self.get_buildings(planet)])
planet_sum_buildings.append((planet, buildings_sum))
totals.append(buildings_sum)
weaker_planets = [planet_sum[0]
for planet_sum
in planet_sum_buildings
if planet_sum[1] == min(totals)]
weaker_planet = next(iter(weaker_planets), None)
return weaker_planet
def get_available_building_for_planet(self, planet):
""" Returns the first structure on planet that has enough resources to be built """
buildings = self.get_available_buildings_for_planet(planet)
building = next(iter(buildings), None)
return building
def get_available_buildings_for_planet(self, planet):
""" Returns the the structures on planet that has enough resources to be built """
url = self.url_provider.get_page_url('resources', planet)
resp = self.open_url(url)
soup = BeautifulSoup(resp.read(), "lxml")
build_images = soup.findAll("a", {"class": "fastBuild tooltip js_hideTipOnMobile"})
buildings = []
for build_image in build_images:
parent_block = build_image.parent
building_btn = parent_block.find("a", {"id": "details"})
building = self.get_building_data_from_button(building_btn)
if building is not None:
buildings.append(building.item)
return buildings
def build_structure(self, building_data, planet):
if self.is_in_construction_mode(planet):
self.logger.info('Planet %s is already in construction mode' % planet.name)
return
else:
self.logger.info('Building %s on planet %s' % (building_data.name, planet.name))
self.build_structure_item(building_data)
def build_structure_item(self, building_data, planet=None):
"""
Building structure to planet,
it doesn't need the planet parameter if the browser
is already at the resources page of the planet
"""
if planet is not None:
url = self.url_provider.get_page_url('resources', planet)
self.open_url(url)
self.create_control("form", "text", "menge", "1")
self.create_control("form", "text", "type", str(building_data.id))
self.create_control("form", "text", "modus", "1")
self.logger.info("Submitting form")
self.submit_request()
def is_in_construction_mode(self, planet=None):
"""
Check if the planet is in construction mode
:param planet: planet to check
:return: True if the planet is in construction mode, otherwise returns False
"""
url = self.url_provider.get_page_url('resources', planet)
resp = self.open_url(url)
soup = BeautifulSoup(resp.read(), "lxml")
# if the planet is in construction mode there shoud be a div with the
# class construction
return soup.find("div", {"class": "construction"}) is not None
class Client:
token = None
expire = None
def __init__(self, username=None, password=None):
self.general = General(self)
self.model = Model(self)
self.actions = Actions(self)
self.groups = Groups(self)
self.customers = Customers(self)
self.segments = Segments(self)
self.integrations = Integrations(self)
if username and password:
self.general.login(username, password)
def _headers(self):
headers = {
'Accept': 'application/JSON',
'Content-type': 'application/JSON'
}
if self.token:
headers['Authorization-Token'] = self.token
return headers
def refresh_token(self):
if not self.expire or (self.expire -
datetime.utcnow()).seconds >= 1200:
self.general.login(self.general.username, self.general.password)
return
def get(self, url, payload=None, headers=None, check_token=True):
if check_token:
self.refresh_token()
headers = headers if headers else self._headers()
response = requests.get(url, params=payload, headers=headers)
return self.dispatch_response(response)
def post(self, url, payload=None, headers=None, check_token=True):
if check_token:
self.refresh_token()
headers = headers if headers else self._headers()
response = requests.post(url,
data=json.dumps(payload),
headers=headers)
return self.dispatch_response(response)
@staticmethod
def bad_request():
raise Exception('Bad Request')
@staticmethod
def unauthorized():
raise Exception('Unauthorized')
@staticmethod
def method_not_allowed():
raise Exception('Method Not allowed')
@staticmethod
def internal_server_error():
raise Exception('Internal Server error')
def dispatch_response(self, response):
if response.status_code == 200:
return response
elif response.status_code == 400:
return self.bad_request()
elif response.status_code == 401:
return self.unauthorized()
elif response.status_code == 405:
return self.method_not_allowed()
elif response.status_code == 500:
return self.internal_server_error()
else:
return False
class Buildings:
def __init__(self, browser, universe):
self.url_provider = util.UrlProvider(universe)
self.logger = logging.getLogger('ogame-bot')
self.browser = browser
self.general_client = General(browser, universe)
def parse_buildings(self, buildings):
planet_buildings = {}
count = 0
for building_type in BuildingTypes:
planet_buildings[building_type] = Building(buildings[count][0], buildings[count][1])
count += 1
return planet_buildings
def get_buildings(self, planet):
self.logger.info('Getting buildings data')
url = self.url_provider.get_page_url('resources', planet)
res = self.browser.open(url)
soup = BeautifulSoup(res.read(), "lxml")
refs = soup.findAll("span", { "class" : "textlabel" })
res = []
for ref in refs:
if ref.parent['class'] == ['level']:
aux = ref.parent.text.replace('\t','')
shipData = re.sub(' +', '', aux).encode('utf8')
res.append( tuple(shipData.split('\n')))
parsed_res = map(tuple, map(util.sanitize, [filter(None, i) for i in res]))
buildings = self.parse_buildings(parsed_res)
return buildings
def auto_build_structure(self, planet):
if self.construction_mode(planet):
self.logger.info('Planet is already in construction mode')
return
else:
resources = self.general_client.get_resources(planet)
buildings = self.get_buildings(planet)
crystal_mine_level = buildings.get(BuildingTypes.CrystalMine).level
metal_mine_level = buildings.get(BuildingTypes.MetalMine).level
deuterium_synthesizer_level = buildings.get(BuildingTypes.DeuteriumSynthesizer).level
metal_storage_level = buildings.get(BuildingTypes.MetalStorage).level
crystal_storage_level = buildings.get(BuildingTypes.CrystalStorage).level
deuterium_tank_level = buildings.get(BuildingTypes.DeuteriumTank).level
if resources.energy < 0:
self.build_structure_item(BuildingTypes.SolarPlant, planet)
else:
if crystal_mine_level - metal_mine_level > 2:
if crystal_storage_level == 0 or crystal_mine_level / crystal_storage_level > 3:
self.build_structure_item(BuildingTypes.CrystalStorage, planet)
else:
self.build_structure_item(BuildingTypes.CrystalMine, planet)
else:
if deuterium_synthesizer_level - metal_mine_level > 5:
if deuterium_tank_level == 0 or deuterium_synthesizer_level / deuterium_tank_level > 3:
self.build_structure_item(BuildingTypes.DeuteriumTank, planet)
else:
self.build_structure_item(BuildingTypes.DeuteriumSynthesizer, planet)
else:
if metal_storage_level == 0 or metal_mine_level / metal_storage_level > 3:
self.build_structure_item(BuildingTypes.MetalStorage, planet)
else:
self.build_structure_item(BuildingTypes.MetalMine, planet)
def build_structure(self, type, planet):
if self.construction_mode(planet):
self.logger.info('Planet is already in construction mode')
return
else:
self.build_structure_item(type.value, planet)
def build_structure_item(self, type, planet = None):
self.logger.info('Building %s on planet %s' %(type, planet.name))
self.browser.select_form(name='form')
self.browser.form.new_control('text','menge',{'value':'1'})
self.browser.form.fixup()
self.browser['menge'] = '1'
self.browser.form.new_control('text','type',{'value': str(type)})
self.browser.form.fixup()
self.browser['type'] = str(type)
self.browser.form.new_control('text','modus',{'value':'1'})
self.browser.form.fixup()
self.browser['modus'] = '1'
self.logger.info("Submitting form")
self.browser.submit()
def construction_mode(self, planet = None):
url = self.url_provider.get_page_url('resources', planet)
self.logger.info('Opening url %s' % url)
resp = self.browser.open(url)
soup = BeautifulSoup(resp.read())
# if the planet is in construction mode there shoud be a div with the class construction
return soup.find("div", {"class" : "construction"}) != None
def overview(self):
print(General(self.browser).get_resources())
print(Buildings(self.browser).get_buildings_data())
# -*- coding: utf-8 -*-
from general import General
from mock import Mock
from mock import patch
g = General()
print g.hello('jesse')
print g.bye()
mock = Mock()
mock.method(1, 3, 4, name="fred")
mock.method.assert_called_with(1, 3, 4, name="fred")
mock.test(1,2)
mock.test.assert_called_once_with(1,2)
mock.reset_mock()
print mock.called
with patch.object('General', return_value=None) as g:
with patch('g.hello', return_value="Dog") as hello:
parent.attach_mock(hello, 'hello')
print hello()
#
def general(self):
self.sonido_boton.reproducir()
pilas.almacenar_escena(General())
class Client:
token = None
expire = None
def __init__(self, username=None, password=None, timeout=TIMEOUT, url=DEFAULT_URL):
self.general = General(self)
self.model = Model(self)
self.actions = Actions(self)
self.groups = Groups(self)
self.customers = Customers(self)
self.segments = Segments(self)
self.integrations = Integrations(self)
self.timeout = timeout
self._url = url
if username and password:
self.general.login(username, password)
def _headers(self):
headers = {
'Accept': 'application/json',
'Content-type': 'application/json'
}
if self.token:
headers['Authorization-Token'] = self.token
return headers
def _refresh_token(self):
if not self.expire or (datetime.utcnow() - self.expire).seconds >= 1200:
self.general.login(self.general.username, self.general.password)
return
def get(self, url, payload=None, headers=None, check_token=True):
if check_token:
self._refresh_token()
headers = headers if headers else self._headers()
LOGGER.debug("GET request: url=%s, payload=%s, headers=%s", url, payload, headers)
if payload:
payload = OrderedDict(sorted(payload.items(), key=lambda t: t[0]))
try:
response = requests.get(url, params=payload, headers=headers, timeout=self.timeout)
except requests.exceptions.Timeout as error:
LOGGER.error("Timeout reached, error=%s", error)
raise Exception('Timeout reached {}sec, url is {}'.format(self.timeout, url))
LOGGER.debug("GET response: url=%s, response_data=%s", response.url, response.text)
return self.dispatch_response(response)
def post(self, url, payload=None, headers=None, check_token=True):
if check_token:
self._refresh_token()
headers = headers if headers else self._headers()
data = json.dumps(payload)
LOGGER.debug("POST request: url=%s, data=%s, headers=%s", url, payload, headers)
try:
response = requests.post(url, data=data, headers=headers, timeout=self.timeout)
except requests.exceptions.Timeout as error:
LOGGER.error("Timeout reached, error=%s", error)
raise Exception('Timeout reached {}sec, url is {}'.format(self.timeout, url))
LOGGER.debug("POST response: url=%s, response_data=%s", url, response.text)
return self.dispatch_response(response)
@staticmethod
def bad_request():
raise Exception('Bad Request')
@staticmethod
def unauthorized():
raise Exception('Unauthorized')
@staticmethod
def method_not_allowed():
raise Exception('Method Not allowed')
@staticmethod
def internal_server_error():
raise Exception('Internal Server error')
def dispatch_response(self, response):
if response.status_code == 200:
return response
elif response.status_code == 400:
return self.bad_request()
elif response.status_code == 401:
return self.unauthorized()
elif response.status_code == 405:
return self.method_not_allowed()
elif response.status_code == 500:
return self.internal_server_error()
else:
return False
def get_url(self):
outer_frames = getouterframes(currentframe(), 2)[1]
category_name = outer_frames[1].split('/')[-1].split('.')[0]
method_name = outer_frames[3]
if '_' in method_name:
action_name_list = [part.upper() if part == 'id' else part.capitalize() for part in method_name.split('_')]
action_name = ''.join(action_name_list)
else:
action_name = method_name
return '%s/current/%s/%s' % (self._url, category_name, action_name)
class Client:
token = None
expire = None
def __init__(self,
username=None,
password=None,
timeout=TIMEOUT,
url=DEFAULT_URL):
self.general = General(self)
self.model = Model(self)
self.actions = Actions(self)
self.groups = Groups(self)
self.customers = Customers(self)
self.segments = Segments(self)
self.integrations = Integrations(self)
self.timeout = timeout
self._url = url
if username and password:
self.general.login(username, password)
def _headers(self):
headers = {
'Accept': 'application/json',
'Content-type': 'application/json'
}
if self.token:
headers['Authorization-Token'] = self.token
return headers
def _refresh_token(self):
if not self.expire or (datetime.utcnow() -
self.expire).seconds >= 1200:
self.general.login(self.general.username, self.general.password)
return
def get(self, url, payload=None, headers=None, check_token=True):
if check_token:
self._refresh_token()
headers = headers if headers else self._headers()
LOGGER.debug("GET request: url=%s, payload=%s, headers=%s", url,
payload, headers)
if payload:
payload = OrderedDict(sorted(payload.items(), key=lambda t: t[0]))
try:
response = requests.get(url,
params=payload,
headers=headers,
timeout=self.timeout)
except requests.exceptions.Timeout as error:
LOGGER.error("Timeout reached, error=%s", error)
raise Exception('Timeout reached {}sec, url is {}'.format(
self.timeout, url))
LOGGER.debug("GET response: url=%s, response_data=%s", response.url,
response.text)
return self.dispatch_response(response)
def post(self, url, payload=None, headers=None, check_token=True):
if check_token:
self._refresh_token()
headers = headers if headers else self._headers()
data = json.dumps(payload)
LOGGER.debug("POST request: url=%s, data=%s, headers=%s", url, payload,
headers)
try:
response = requests.post(url,
data=data,
headers=headers,
timeout=self.timeout)
except requests.exceptions.Timeout as error:
LOGGER.error("Timeout reached, error=%s", error)
raise Exception('Timeout reached {}sec, url is {}'.format(
self.timeout, url))
LOGGER.debug("POST response: url=%s, response_data=%s", url,
response.text)
return self.dispatch_response(response)
@staticmethod
def bad_request():
raise Exception('Bad Request')
@staticmethod
def unauthorized():
raise Exception('Unauthorized')
@staticmethod
def method_not_allowed():
raise Exception('Method Not allowed')
@staticmethod
def internal_server_error():
raise Exception('Internal Server error')
def dispatch_response(self, response):
if response.status_code == 200:
return response
elif response.status_code == 400:
return self.bad_request()
elif response.status_code == 401:
return self.unauthorized()
elif response.status_code == 405:
return self.method_not_allowed()
elif response.status_code == 500:
return self.internal_server_error()
else:
return False
def get_url(self):
outer_frames = getouterframes(currentframe(), 2)[1]
category_name = outer_frames[1].split('/')[-1].split('.')[0]
method_name = outer_frames[3]
if '_' in method_name:
action_name_list = [
part.upper() if part == 'id' else part.capitalize()
for part in method_name.split('_')
]
action_name = ''.join(action_name_list)
else:
action_name = method_name
return '%s/current/%s/%s' % (self._url, category_name, action_name)
def __init__(self, browser, config):
super(Buildings, self).__init__(browser, config)
self.general_client = General(browser, config)
class Movement(Scraper):
def __init__(self, browser, config):
super(Movement, self).__init__(browser, config)
self.general_client = General(browser, config)
def get_fleet_movement_from_movement_page(self):
"""
Deprecated, use get_fleet_movement instead
:return:
"""
url = self.url_provider.get_page_url('movement')
res = self.open_url(url)
soup = BeautifulSoup(res.read(), "lxml")
movement_nodes = soup.findAll("div",
{"class": "fleetDetails detailsOpened"})
fleet_movements = []
for movement_node in movement_nodes:
mission_code = int(movement_node['data-mission-type'])
mission_type = self.mission_types[mission_code]
origin_planet_coords = self.parse_coords(
movement_node.find("span", {
"class": "originCoords"
}).text)
origin_planet_name = movement_node.find("span", {
"class": "originPlanet"
}).text.strip()
destination_coords = self.parse_coords(
movement_node.find("span", {
"class": "destinationCoords tooltip"
}).text)
movement = FleetMovement(origin_planet_coords, origin_planet_name,
destination_coords)
movement.mission = mission_type
fleet_movements.append(movement)
return fleet_movements
def get_fleet_movement(self):
url = self.url_provider.get_page_url('eventList')
res = self.open_url(url)
soup = BeautifulSoup(res.read(), "lxml")
movement_table = soup.find("table", {"id": "eventContent"})
movement_rows = movement_table.findAll("tr", {"class": "eventFleet"})
fleet_movements = []
for movement_row in movement_rows:
try:
mission_code = int(movement_row['data-mission-type'])
mission_type = self.mission_types[mission_code]
origin_coords = self.parse_coords(
movement_row.find("td", {
"class": "coordsOrigin"
}).text.strip())
origin_planet_name = movement_row.find("td", {
"class": "originFleet"
}).text.strip()
dest_coords = self.parse_coords(
movement_row.find("td", {
"class": "destCoords"
}).text.strip())
dest_planet_data = movement_row.find("td",
{"class": "destFleet"})
dest_planet_name = movement_row.find("td", {
"class": "destFleet"
}).text.strip()
isMoon = False if dest_planet_data.find(
"figure", {"class": "moon"}) is None else True
count_down_td = movement_row.find("td", {"class": "countDown"})
is_friendly = 'friendly' in count_down_td.attrs['class']
arrival_time_str = movement_row.find("td", {
"class": "arrivalTime"
}).text
arrival_time = get_arrival_time(arrival_time_str)
countdown_time = self.get_countdown_time(arrival_time)
movement = FleetMovement(origin_coords, origin_planet_name,
dest_coords, dest_planet_name,
is_friendly, arrival_time,
countdown_time, mission_type, isMoon)
fleet_movements.append(movement)
except Exception as e:
exception_message = traceback.format_exc()
self.logger.error(exception_message)
return fleet_movements
def get_countdown_time(self, arrival_time):
game_time = self.general_client.get_game_datetime()
return arrival_time - game_time
@staticmethod
def parse_coords(text):
return text.replace('[', '').replace(']', '')
def get_fleet_slots_usage(self):
"""
Get fleet slot usage data. Only works if there is at least 1 fleet in movement
"""
url = self.url_provider.get_page_url('movement')
res = self.open_url(url)
soup = BeautifulSoup(res.read())
slots_info_node = soup.find("span", {"class", "fleetSlots"})
if slots_info_node is not None:
current_slots = int(
slots_info_node.find("span", {"class", "current"}).text)
all_slots = int(
slots_info_node.find("span", {"class", "all"}).text)
else:
current_slots = 0
all_slots = 1
return current_slots, all_slots
def __init__(self, browser, config):
super(Movement, self).__init__(browser, config)
self.general_client = General(browser, config)
def __init__(self):
self.general = General()
self.general.draw_gui()
def __init__(self, browser, universe):
self.url_provider = util.UrlProvider(universe)
self.logger = logging.getLogger('ogame-bot')
self.browser = browser
self.general_client = General(browser, universe)
def __init__(self, browser, config):
super(Buildings, self).__init__(browser, config)
self.general_client = General(browser, config)
# -*- coding: utf-8 -*-
from general import General
from mock import Mock
from mock import patch
g = General()
print g.hello('jesse')
print g.bye()
mock = Mock()
mock.method(1, 3, 4, name="fred")
mock.method.assert_called_with(1, 3, 4, name="fred")
mock.test(1, 2)
mock.test.assert_called_once_with(1, 2)
mock.reset_mock()
print mock.called
with patch.object('General', return_value=None) as g:
with patch('g.hello', return_value="Dog") as hello:
parent.attach_mock(hello, 'hello')
print hello()
#
def __init__(self):
"""
This constructor instantiates a game board, instantiates and adds the game piece objects to the board,
initializes the game state to "unfinished", initializes the current turn as the red players,
and initializes the in-check status of the players.
"""
self._board = self._board = {
"a1": None,
"b1": None,
"c1": None,
"d1": None,
"e1": None,
"f1": None,
"g1": None,
"h1": None,
"i1": None,
# row 2
"a2": None,
"b2": None,
"c2": None,
"d2": None,
"e2": None,
"f2": None,
"g2": None,
"h2": None,
"i2": None,
# row 3
"a3": None,
"b3": None,
"c3": None,
"d3": None,
"e3": None,
"f3": None,
"g3": None,
"h3": None,
"i3": None,
# row 4
"a4": None,
"b4": None,
"c4": None,
"d4": None,
"e4": None,
"f4": None,
"g4": None,
"h4": None,
"i4": None,
# row 5
"a5": None,
"b5": None,
"c5": None,
"d5": None,
"e5": None,
"f5": None,
"g5": None,
"h5": None,
"i5": None,
# row 6
"a6": None,
"b6": None,
"c6": None,
"d6": None,
"e6": None,
"f6": None,
"g6": None,
"h6": None,
"i6": None,
# row 7
"a7": None,
"b7": None,
"c7": None,
"d7": None,
"e7": None,
"f7": None,
"g7": None,
"h7": None,
"i7": None,
# row 8
"a8": None,
"b8": None,
"c8": None,
"d8": None,
"e8": None,
"f8": None,
"g8": None,
"h8": None,
"i8": None,
# row 9
"a9": None,
"b9": None,
"c9": None,
"d9": None,
"e9": None,
"f9": None,
"g9": None,
"h9": None,
"i9": None,
# row 10
"a10": None,
"b10": None,
"c10": None,
"d10": None,
"e10": None,
"f10": None,
"g10": None,
"h10": None,
"i10": None,
}
self._red_pieces = []
self._black_pieces = []
red_char_1 = Chariot("red", "a1")
self.update_board("a1", red_char_1)
self._red_pieces.append(red_char_1)
black_char_1 = Chariot("Black", "a10")
self.update_board("a10", black_char_1)
self._black_pieces.append(black_char_1)
red_horse_1 = Horse("red", "b1")
self.update_board("b1", red_horse_1)
self._red_pieces.append(red_horse_1)
black_horse_1 = Horse("black", "b10")
self.update_board("b10", black_horse_1)
self._black_pieces.append(black_horse_1)
red_ele_1 = Elephant("red", "c1")
self.update_board("c1", red_ele_1)
self._red_pieces.append(red_ele_1)
black_ele_1 = Elephant("black", "c10")
self.update_board("c10", black_ele_1)
self._black_pieces.append(black_ele_1)
red_adv_1 = Advisor("red", "d1")
self.update_board("d1", red_adv_1)
self._red_pieces.append(red_adv_1)
black_adv_1 = Advisor("black", "d10")
self.update_board("d10", black_adv_1)
self._black_pieces.append(black_adv_1)
red_gen = General("red", "e1")
self.update_board("e1", red_gen)
self._red_pieces.append(red_gen)
black_gen = General("Black", "e10")
self.update_board("e10", black_gen)
self._black_pieces.append(black_gen)
red_adv_2 = Advisor("Red", "f1")
self.update_board("f1", red_adv_2)
self._red_pieces.append(red_adv_2)
black_adv_2 = Advisor("black", "f10")
self.update_board("f10", black_adv_2)
self._black_pieces.append(black_adv_2)
red_ele_2 = Elephant("red", "g1")
self.update_board("g1", red_ele_2)
self._red_pieces.append(red_ele_2)
black_ele_2 = Elephant("black", "g10")
self.update_board("g10", black_ele_2)
self._black_pieces.append(black_ele_2)
red_horse_2 = Horse("red", "h1")
self.update_board("h1", red_horse_2)
self._red_pieces.append(red_horse_2)
black_horse_2 = Horse("black", "h10")
self.update_board("h10", black_horse_2)
self._black_pieces.append(black_horse_2)
red_char_2 = Chariot("red", "i1")
self.update_board("i1", red_char_2)
self._red_pieces.append(red_char_2)
black_char_2 = Chariot("black", "i10")
self.update_board("i10", black_char_2)
self._black_pieces.append(black_char_2)
red_can_1 = Cannon("red", "b3")
self.update_board("b3", red_can_1)
self._red_pieces.append(red_can_1)
black_can_1 = Cannon("black", "b8")
self.update_board("b8", black_can_1)
self._black_pieces.append(black_can_1)
red_can_2 = Cannon("red", "h3")
self.update_board("h3", red_can_2)
self._red_pieces.append(red_can_2)
black_can_2 = Cannon("black", "h8")
self.update_board("h8", black_can_2)
self._black_pieces.append(black_can_2)
red_sol_1 = Soldier("red", "a4")
self.update_board("a4", red_sol_1)
self._red_pieces.append(red_sol_1)
red_sol_2 = Soldier("red", "c4")
self.update_board("c4", red_sol_2)
self._red_pieces.append(red_sol_2)
red_sol_3 = Soldier("red", "e4")
self.update_board("e4", red_sol_3)
self._red_pieces.append(red_sol_3)
red_sol_4 = Soldier("red", "g4")
self.update_board("g4", red_sol_4)
self._red_pieces.append(red_sol_4)
red_sol_5 = Soldier("red", "i4")
self.update_board("i4", red_sol_5)
self._red_pieces.append(red_sol_5)
black_sol_1 = Soldier("black", "a7")
self.update_board("a7", black_sol_1)
self._black_pieces.append(black_sol_1)
black_sol_2 = Soldier("black", "c7")
self.update_board("c7", black_sol_2)
self._black_pieces.append(black_sol_2)
black_sol_3 = Soldier("black", "e7")
self.update_board("e7", black_sol_3)
self._black_pieces.append(black_sol_3)
black_sol_4 = Soldier("black", "g7")
self.update_board("g7", black_sol_4)
self._black_pieces.append(black_sol_4)
black_sol_5 = Soldier("black", "i7")
self.update_board("i7", black_sol_5)
self._black_pieces.append(black_sol_5)
self._game_state = "UNFINISHED"
self._turn = True
self.generate_moves()
self._red_in_check = {"red": False}
self._black_in_check = {"black": False}
