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 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)
# -*- 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}