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 __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 __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 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 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,
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, 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 __init__(self, browser, config):
super(Movement, self).__init__(browser, config)
self.general_client = General(browser, config)
def __init__(self, browser, config):
super(Buildings, self).__init__(browser, config)
self.general_client = General(browser, config)
def overview(self):
print(General(self.browser).get_resources())
print(Buildings(self.browser).get_buildings_data())
def general(self):
self.sonido_boton.reproducir()
pilas.almacenar_escena(General())
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}
def __init__(self, browser, config):
super(Research, self).__init__(browser, config)
self.general_client = General(browser, config)
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'))
# -*- 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()
#
