def main():
player1 = None
player2 = None
player1Type = util.get_arg(1)
player2Type = util.get_arg(2)
if player1Type == None or player2Type == None:
print('Invalid use of connect3 game')
return
if player1Type == 'human':
player1 = HumanPlayer('X')
elif player1Type == 'random':
player1 = RandomPlayer('X')
elif player1Type == 'minimax':
player1 = MinimaxPlayer('X')
if player2Type == 'human':
player2 = HumanPlayer('O')
elif player2Type == 'random':
player2 = RandomPlayer('O')
elif player2Type == 'minimax':
player2 = MinimaxPlayer('O')
game = Game(player1, player2)
winner = game.play()
print('Winner:', winner)
def main():
command = util.get_arg(1)
state = rgb.State(util.get_arg(2))
agent = Agent()
if command == 'random':
agent.random_walk(state, DEFAULT_N)
elif command == 'bfs':
start_time = time.time()
iterations = agent.bfs(state)
print("Iterations needed: %s" % iterations)
print("Time taken: %s seconds" % (time.time() - start_time))
elif command == 'dfs':
start_time = time.time()
iterations = agent.dfs(state)
print("Iterations needed: %s" % iterations)
print("Time taken: %s seconds" % (time.time() - start_time))
elif command == 'a_star':
start_time = time.time()
iterations = agent.a_star(state, heuristic)
print("Iterations needed: %s" % iterations)
print("Time taken: %s seconds" % (time.time() - start_time))
else:
print('Invalid command inputed')
def __init__(self, kwargs):
self.id = util.get_arg(kwargs, 'id')
self.object = util.get_arg(kwargs, 'object')
self.date_created = util.get_arg(kwargs, 'date_created')
self.last_updated = util.get_arg(kwargs, 'last_updated')
self.email_address = util.get_arg(kwargs, 'email_address')
self.first_name = util.get_arg(kwargs, 'first_name')
self.last_name = util.get_arg(kwargs, 'last_name')
self.mobile_country_code = util.get_arg(kwargs, 'mobile_country_code')
self.mobile_number = util.get_arg(kwargs, 'mobile_number')
self.object_reference_id = util.get_arg(kwargs, 'object_reference_id')
def refund(**kwargs):
order_id = util.get_arg(kwargs,'order_id')
unique_request_id = util.get_arg(kwargs, 'unique_request_id')
if order_id is None or unique_request_id is None:
raise InvalidArguementException('`order_id` & `unique_request_id` is a required argument for Order.refund()\n')
method = 'POST'
url = '/order/refund'
response = util.request(method, url, kwargs).json()
order = Orders.Order(response)
return order
def test():
ret = ''
ret += 'get_args() = ' + str(util.get_args()) + '\n'
ret += '\n'
ret += 'get_args_len() = ' + str(util.get_args_len()) + '\n'
ret += '\n'
ret += 'get_arg(0) = ' + util.get_arg(0) + '\n'
ret += 'get_arg(1) = ' + util.get_arg(1) + '\n'
ret += 'get_arg(2) = ' + util.get_arg(2) + '\n'
ret += 'get_arg(3, \'-\') = ' + util.get_arg(3, '-') + '\n'
return ret
def create_suggestion(bot, message):
arg = util.get_arg(message.text)
if (arg == None or len(arg) == 0):
bot.reply_to(message, "Insira a sugestão junto com o comando")
else:
dbi.create_suggestion(message.from_user.username, arg)
bot.reply_to(message, "Sugestão salva!")
def set_mandamento(bot, message):
arg = util.get_arg(message.text)
if (arg == None or len(arg) == 0):
bot.reply_to(message, "Oh seu animal, tem q mandar alguma coisa né?!")
else:
dbi.insert_commandment(message.from_user.username, arg)
bot.reply_to(message, "Mandamento salvo!")
def refreshBalance(**kwargs):
customer_id = util.get_arg(kwargs,'customer_id')
if customer_id is None:
raise InvalidArguementException('`customer_id` is a required argument for Wallets.refreshBalance()\n')
method = 'GET'
url = '/customers/%s/wallets/refresh-balances' % (customer_id)
response = util.request(method, url, {}).json()
response = util.get_arg(response,'list')
wallets = []
if response is not None:
for wallet in response:
wallet = Wallets.Wallet(wallet)
wallets.append(wallet)
return wallets
def add_corona(message):
print('aehooo')
arg = util.get_arg(message.text)
if (arg == None or len(arg) == 0):
bot.reply_to(message, "Oh seu animal, tem q mandar alguma coisa né?!")
else:
dbi.insert_corona(message.from_user.username, arg)
bot.reply_to(message, "Corona salvo!")
def status(**kwargs):
order = util.get_arg(kwargs,'order_id')
if order is None:
raise InvalidArguementException('`order_id` is a required argument for Order.status()\n')
method = 'GET'
url = '/order/status'
response = util.request(method, url, kwargs).json()
order = Orders.Order(response)
return order
def update(**kwargs):
order_id = util.get_arg(kwargs,'order_id')
if order_id is None:
raise InvalidArguementException('`order_id` is a required argument for Order.update()\n')
method = 'POST'
url = '/order/create'
response = util.request(method, url, kwargs).json()
order = Orders.Order(response)
return order
def ex_rate(bot, message):
arg = util.get_arg(message.text)
content = util.get("https://api.exchangeratesapi.io/latest?base=" + arg +
"&symbols=BRL")
obj = json.loads(content)
print(str(obj))
if 'error' in obj:
bot.reply_to(message, str(obj['error']))
return
bot.reply_to(message, "R$" + str(obj['rates']['BRL']))
def delete_event(bot, message):
arg = util.get_arg(message.text)
if len(arg) == 0:
bot.reply_to(message, "Que tal escrever o nome do evento?")
return
if not dbi.event_exists(arg):
bot.reply_to(message, "Não existe evento com nome " + arg)
return
dbi.delete_event(arg)
bot.reply_to(message, "Evento deletado!")
def find_event(bot, message):
arg = util.get_arg(message.text)
print("[" + arg + "]")
if len(arg) == 0:
bot.reply_to(message, "Escreva o nome de um evento")
return
if not dbi.event_exists(arg):
bot.reply_to(message, "Não existe evento com nome " + arg)
return
row = dbi.find_event_by_name(arg)
bot.reply_to(message, "Nome: " + row[0] + "\nDescrição:\n" + row[1])
def find_all_events(bot, message):
arg = util.get_arg(message.text)
print("[" + arg + "]")
if not arg.isdigit():
arg = 5
event_name_list = dbi.find_all_events(int(arg))
s = ""
for event_name in event_name_list:
s += event_name[0] + "\n"
bot.reply_to(message,
"Últimos " + str(len(event_name_list)) + " eventos:\n" + s)
def choose_action(state):
char = util.get_arg(1)
random_list = []
a = 0
for action in state.actions(char):
print(str(a) + ": ", end='')
print(action)
random_list.append(a)
a = a + 1
random_input = random.choice(random_list)
return random_input
def choose_action(state):
#print(state)
#char = util.get_arg(2)
char = util.get_arg(1)
a = 0
for action in state.actions(char):
print(str(a) + ": ", end='')
print(action)
a = a + 1
user_input = input("Please choose an action: ")
return user_input
def find_mandamento(bot, message):
arg = util.get_arg(message.text)
if not arg.isdigit():
bot.reply_to(message, "Que tal experimentar um número?")
return
commandment = dbi.find_commandment(int(arg))
if commandment == None:
bot.reply_to(message, "Ainda não há um mandamento com este número")
return
s = str(commandment[0]) + ": \"" + str(commandment[3]) + "\"\n"
bot.send_message(message.chat.id, s)
def update(**kwargs):
id = util.get_arg(kwargs,'id')
if id is None:
raise InvalidArguementException(message='`id` is a required argument for Customers.update()\n')
method = 'POST'
url = '/customers/%s' % (id)
response = util.request(method, url, kwargs).json()
customer = Customers.Customer(response)
return customer
def __init__(self, kwargs):
self.rrn = util.get_arg(kwargs, 'rrn')
self.epg_txn_id = util.get_arg(kwargs, 'epg_txn_id')
self.auth_id_code = util.get_arg(kwargs, 'auth_id_code')
self.txn_id = util.get_arg(kwargs, 'txn_id')
self.resp_code = util.get_arg(kwargs, 'resp_code')
self.resp_message = util.get_arg(kwargs, 'resp_message')
def __init__(self, kwargs):
self.id = util.get_arg(kwargs, 'id')
self.object = util.get_arg(kwargs, 'object')
self.wallet = util.get_arg(kwargs, 'wallet')
self.token = util.get_arg(kwargs, 'token')
self.current_balance = util.get_arg(kwargs, 'current_balance')
self.last_refreshed = util.get_arg(kwargs, 'last_refreshed')
def list(**kwargs):
method = 'GET'
url = '/customers'
offset = util.get_arg(kwargs,'offset')
count = util.get_arg(kwargs,'count')
if count is None and offset is None:
sys.stderr.write('`count` & `offset` can be passed if required.\n')
response = util.request(method, url, kwargs or {}).json()
response_list = util.get_arg(response,'list')
customers_list = []
customer_list_response = {}
if response is not None:
for customer in response_list:
customer = Customers.Customer(customer)
customers_list.append(customer)
customer_list_response = {
'count' : response['count'],
'offset': response['offset'],
'total' : response['total'],
'list' :customers_list
}
return customer_list_response
def __get_weibo_info(self, page=1):
self.__weibo_detail.clear()
request = requests.get(
url=self.__WEIBOS_LIST_API.format(weibo_url=self.weibo_url, page=page),
headers=self.__headers)
request.encoding = 'utf-8'
bs = BeautifulSoup(request.text, 'lxml')
for script in bs.select('script'):
weibo_json_str = re.search(r'(?<=FM.view\()(.*)(?=\))', str(script))
if weibo_json_str:
weibo_json_obj = json.loads(weibo_json_str.group())
if 'Pl_Official_MyProfileFeed' in weibo_json_obj['domid']:
bs = BeautifulSoup(weibo_json_obj['html'], 'lxml')
break
weibos = bs.select('div[mid].WB_cardwrap')
for weibo in weibos:
weibo_content = clean_content(weibo, prefix='>').replace('\u200b', '').strip()
weibo_send_time = weibo.select_one('a[node-type="feed_list_item_date"]').getText().strip()
weibo_send_time = get_abs_time(weibo_send_time)
weibo_detail_url = 'https://weibo.com' + weibo.select_one('a[node-type="feed_list_item_date"]').get('href')
weibo_transfer_num = weibo.select_one('span[node-type="forward_btn_text"]').getText().strip()[1:]
weibo_comment_num = weibo.select_one('span[node-type="comment_btn_text"]').getText().strip()[1:]
weibo_like_num = weibo.select_one('span[node-type="like_status"]').getText().strip()[1:]
weibo_media_urls = []
weibo_media_pics = weibo.select('div .WB_media_wrap .WB_pic img')
for pic in weibo_media_pics:
weibo_media_urls.append('https:' + pic.get('src').replace('thumb180', 'mw690'))
weibo_media_videos = weibo.select('div .WB_media_wrap .WB_video')
for video in weibo_media_videos:
get_str = urllib.parse.unquote(video.get('action-data'))
weibo_media_urls.append(get_arg(get_str, 'short_url'))
self.__weibo_detail[weibo.get('mid')] = {
'content': weibo_content,
'send_time': weibo_send_time,
'detail_url': weibo_detail_url,
'transfer': weibo_transfer_num,
'comment': weibo_comment_num,
'like': weibo_like_num,
'media_urls': weibo_media_urls
}
time.sleep(self.__INTERVAL)
def create_event(bot, message):
arg = util.get_arg(message.text)
print("[" + arg + "]")
if len(arg) == 0:
bot.reply_to(message, "Que tal escrever o nome do evento?")
return
event_parts = arg.split("###")
if len(event_parts) == 1:
bot.reply_to(
message,
"""Utilize \"###\" para separar o nome da descrição do evento\n
exemplo: /create-event festa da paula###paula dentro, paula fora"""
)
return
dbi.create_event(message.from_user.username, event_parts[0],
event_parts[1])
bot.reply_to(message, "Evento criado!")
def update_event(bot, message):
arg = util.get_arg(message.text)
print("[" + arg + "]")
if len(arg) == 0:
bot.reply_to(message, "Escreva o nome de um evento")
return
event_parts = arg.split("###")
if len(event_parts) == 1:
bot.reply_to(
message,
"Utilize \"###\" para separar o nome da descrição do evento")
return
if not dbi.event_exists(event_parts[0]):
bot.reply_to(message, "Não existe evento com nome " + arg)
return
dbi.update_event_description(message.from_user.username, event_parts[0],
event_parts[1])
bot.reply_to(message, "Evento atualizado!\n")
def execute(state, screen, objects=[]):
memory, ptr, base = state
block = []
score = 0
paddle = 0
ball = 0
while ptr < len(memory):
instruction = memory[ptr]
opcode = instruction % 100
modes = instruction // 100
if opcode == 99:
return score
if opcode == 1:
arg1 = util.get_arg(memory, ptr, modes, 1, base)
arg2 = util.get_arg(memory, ptr, modes, 2, base)
arg3 = util.get_arg(memory, ptr, modes, 3, base, True)
memory[arg3] = arg1 + arg2
ptr += 4
elif opcode == 2:
arg1 = util.get_arg(memory, ptr, modes, 1, base)
arg2 = util.get_arg(memory, ptr, modes, 2, base)
arg3 = util.get_arg(memory, ptr, modes, 3, base, True)
memory[arg3] = arg1 * arg2
ptr += 4
elif opcode == 3:
dst = util.get_arg(memory, ptr, modes, 1, base, True)
memory[dst] = (ball > paddle) - (ball < paddle)
ptr += 2
elif opcode == 4:
value = util.get_arg(memory, ptr, modes, 1, base)
block.append(value)
ptr += 2
if len(block) == 3:
x, y, value = block
objects.append((x, y, value))
block = []
if x >= 0 and y >= 0:
screen[y][x] = value
else:
score = value
if value == 3:
paddle = x
elif value == 4:
ball = x
elif opcode == 5:
arg1 = util.get_arg(memory, ptr, modes, 1, base)
arg2 = util.get_arg(memory, ptr, modes, 2, base)
ptr = ptr + 3 if arg1 == 0 else arg2
elif opcode == 6:
arg1 = util.get_arg(memory, ptr, modes, 1, base)
arg2 = util.get_arg(memory, ptr, modes, 2, base)
ptr = arg2 if arg1 == 0 else ptr + 3
elif opcode == 7:
arg1 = util.get_arg(memory, ptr, modes, 1, base)
arg2 = util.get_arg(memory, ptr, modes, 2, base)
arg3 = util.get_arg(memory, ptr, modes, 3, base, True)
memory[arg3] = int(arg1 < arg2)
ptr += 4
elif opcode == 8:
arg1 = util.get_arg(memory, ptr, modes, 1, base)
arg2 = util.get_arg(memory, ptr, modes, 2, base)
arg3 = util.get_arg(memory, ptr, modes, 3, base, True)
memory[arg3] = int(arg1 == arg2)
ptr += 4
elif opcode == 9:
base += util.get_arg(memory, ptr, modes, 1, base)
ptr += 2
import surf
import animate
import util
hide_title = True
large = False
phase_hist = True
def run():
return subprocess.check_output(['make', 'build-run'])
if __name__ == '__main__':
n_z_plots = 10
sequence_dir = util.get_arg('--sequence_dir', '', parse_func=str)
if util.get_flag("-r") or util.get_flag("--rerun"):
out = run()
log = util.get_flag("-log")
if log:
print('log abs y')
dir = '../tmp'
fn = 'out.zip'
size = os.path.getsize(os.path.join(dir, fn))
print(f'Input file size: {size * 1e-6:0.5f} MB')
if size > 1e8:
print(f'Warning, file too large: {size*1e-6:0.4f} MB')
params, data = util.parse_file(dir, fn, 'out')
def execute(state, input):
memory, ptr, base = state
output = []
while ptr < len(memory):
instruction = memory[ptr]
opcode = instruction % 100
modes = instruction // 100
if opcode == 99:
state[:] = memory, ptr, base
return (output, True)
if opcode == 1:
arg1 = util.get_arg(memory, ptr, modes, 1, base)
arg2 = util.get_arg(memory, ptr, modes, 2, base)
arg3 = util.get_arg(memory, ptr, modes, 3, base, True)
memory[arg3] = arg1 + arg2
ptr += 4
elif opcode == 2:
arg1 = util.get_arg(memory, ptr, modes, 1, base)
arg2 = util.get_arg(memory, ptr, modes, 2, base)
arg3 = util.get_arg(memory, ptr, modes, 3, base, True)
memory[arg3] = arg1 * arg2
ptr += 4
elif opcode == 3:
dst = util.get_arg(memory, ptr, modes, 1, base, True)
memory[dst] = input
ptr += 2
elif opcode == 4:
value = util.get_arg(memory, ptr, modes, 1, base)
output.append(value)
ptr += 2
if len(output) == 2:
state[:] = memory, ptr, base
return (output, False)
elif opcode == 5:
arg1 = util.get_arg(memory, ptr, modes, 1, base)
arg2 = util.get_arg(memory, ptr, modes, 2, base)
ptr = ptr + 3 if arg1 == 0 else arg2
elif opcode == 6:
arg1 = util.get_arg(memory, ptr, modes, 1, base)
arg2 = util.get_arg(memory, ptr, modes, 2, base)
ptr = arg2 if arg1 == 0 else ptr + 3
elif opcode == 7:
arg1 = util.get_arg(memory, ptr, modes, 1, base)
arg2 = util.get_arg(memory, ptr, modes, 2, base)
arg3 = util.get_arg(memory, ptr, modes, 3, base, True)
memory[arg3] = int(arg1 < arg2)
ptr += 4
elif opcode == 8:
arg1 = util.get_arg(memory, ptr, modes, 1, base)
arg2 = util.get_arg(memory, ptr, modes, 2, base)
arg3 = util.get_arg(memory, ptr, modes, 3, base, True)
memory[arg3] = int(arg1 == arg2)
ptr += 4
elif opcode == 9:
base += util.get_arg(memory, ptr, modes, 1, base)
ptr += 2
def execute(self, action):
char = self.get(action.x, action.y)
self.put(action.x2, action.y2, char)
self.put(action.x, action.y, Cell.EMPTY)
return self
def pprint_string(self):
top_bottom = util.color_string('+' + ('-' * self.size) + '+',
fore='blue',
back='blue')
side = util.color_string('|', fore='blue', back='blue')
s = top_bottom + '\n'
for y in range(self.size):
s += side + ''.join([Cell.color(c)
for c in self.row(y)]) + side + '\n'
return s + top_bottom
if __name__ == '__main__':
cmd = util.get_arg(1)
if cmd:
state = State(util.get_arg(2))
if cmd == 'print':
util.pprint(state)
elif cmd == 'goal':
print(state.is_goal())
elif cmd == 'actions':
for action in state.actions():
print(action)
def execute(state, input):
memory, ptr, output = state
while ptr < len(memory):
instruction = memory[ptr]
opcode = instruction % 100
modes = instruction // 100
if opcode == 99:
state[:] = memory, ptr, output
return (output, True)
if opcode == 1:
arg1 = util.get_arg(memory, ptr, modes, 1)
arg2 = util.get_arg(memory, ptr, modes, 2)
memory[memory[ptr + 3]] = arg1 + arg2
ptr += 4
elif opcode == 2:
arg1 = util.get_arg(memory, ptr, modes, 1)
arg2 = util.get_arg(memory, ptr, modes, 2)
memory[memory[ptr + 3]] = arg1 * arg2
ptr += 4
elif opcode == 3:
memory[memory[ptr + 1]] = input.pop(0)
ptr += 2
elif opcode == 4:
output = util.get_arg(memory, ptr, modes, 1)
ptr += 2
state[:] = memory, ptr, output
return (output, False)
elif opcode == 5:
arg1 = util.get_arg(memory, ptr, modes, 1)
arg2 = util.get_arg(memory, ptr, modes, 2)
ptr = ptr + 3 if arg1 == 0 else arg2
elif opcode == 6:
arg1 = util.get_arg(memory, ptr, modes, 1)
arg2 = util.get_arg(memory, ptr, modes, 2)
ptr = arg2 if arg1 == 0 else ptr + 3
elif opcode == 7:
arg1 = util.get_arg(memory, ptr, modes, 1)
arg2 = util.get_arg(memory, ptr, modes, 2)
memory[memory[ptr + 3]] = int(arg1 < arg2)
ptr += 4
elif opcode == 8:
arg1 = util.get_arg(memory, ptr, modes, 1)
arg2 = util.get_arg(memory, ptr, modes, 2)
memory[memory[ptr + 3]] = int(arg1 == arg2)
ptr += 4
def __init__(self, kwargs):
if util.check_param(kwargs,'billing_address'):
billing_address = Orders.Order.Address("billing", kwargs)
else:
billing_address = None
if util.check_param(kwargs,'shipping_address'):
shipping_address = Orders.Order.Address("shipping", kwargs)
else:
shipping_address = None
if util.get_arg(kwargs, 'card') is not None:
card = Cards.Card(util.get_arg(kwargs, 'card'))
else:
card = None
if util.get_arg(kwargs, 'payment_gateway_response') is not None:
gateway_response = Orders.Order.GatewayResponse(util.get_arg(kwargs, 'payment_gateway_response'))
else:
gateway_response = None
if 'refunds' in kwargs:
refunds = []
for refund in kwargs['refunds']:
refund_obj = Orders.Order.Refund(refund)
refunds.append(refund_obj)
else:
refunds = None
self.merchant_id = util.get_arg(kwargs, 'merchant_id')
self.order_id = util.get_arg(kwargs, 'order_id')
self.status = util.get_arg(kwargs, 'status')
self.status_id = util.get_arg(kwargs, 'status_id')
self.amount = util.get_arg(kwargs, 'amount')
self.currency = util.get_arg(kwargs, 'currency')
self.customer_id = util.get_arg(kwargs, 'customer_id')
self.customer_email = util.get_arg(kwargs, 'customer_email')
self.customer_phone = util.get_arg(kwargs, 'customer_phone')
self.product_id = util.get_arg(kwargs, 'product_id')
self.return_url = util.get_arg(kwargs, 'return_url')
self.description = util.get_arg(kwargs, 'description')
self.billing_address = billing_address
self.shipping_address = shipping_address
self.udf1 = util.get_arg(kwargs, 'udf1')
self.udf2 = util.get_arg(kwargs, 'udf2')
self.udf3 = util.get_arg(kwargs, 'udf3')
self.udf4 = util.get_arg(kwargs, 'udf4')
self.udf5 = util.get_arg(kwargs, 'udf5')
self.udf6 = util.get_arg(kwargs, 'udf6')
self.udf7 = util.get_arg(kwargs, 'udf7')
self.udf8 = util.get_arg(kwargs, 'udf8')
self.udf9 = util.get_arg(kwargs, 'udf9')
self.udf10 = util.get_arg(kwargs, 'udf10')
self.txn_id = util.get_arg(kwargs, 'txn_id')
self.gateway_id = util.get_arg(kwargs, 'gateway_id')
self.bank_error_code = util.get_arg(kwargs, 'bank_error_code')
self.bank_error_message = util.get_arg(kwargs, 'bank_error_message')
self.refunded = util.get_arg(kwargs, 'refunded')
self.amount_refunded = util.get_arg(kwargs, 'amount_refunded')
self.card = card
self.gateway_response = gateway_response
self.refunds = refunds
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import re
import sys
from subprocess import run
import bs4
import pyminizip
from util import (clean_tags, get_arg, get_function, get_info, get_soup,
set_info, to_md)
arg = get_arg('Genera un epub de un programa electoral')
re_rtrim = re.compile(r" +$", re.MULTILINE)
re_ltrim = re.compile(r"^\s*\n+")
yml = get_info(autocomplete=True)
isLastLineBlank = False
def fprint(txt, *args, re_clean=None, **kargs):
global isLastLineBlank
if isinstance(txt, bs4.Tag):
txt = to_md(txt)
if re_clean is not None:
txt = re_clean.sub("", txt)
txt = re_rtrim.sub("", txt)
if isLastLineBlank:
txt = re_ltrim.sub("", txt)
def __init__(self, kwargs):
self.id = util.get_arg(kwargs, 'refund_id')
self.ref = util.get_arg(kwargs, 'ref')
self.amount = util.get_arg(kwargs, 'amount')
self.created = util.get_arg(kwargs, 'created')
self.status = util.get_arg(kwargs, 'status')
import skimage
import skimage.filters.rank
from skimage.morphology import disk
from skimage import io, transform
import matplotlib.pyplot as plt
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
# import matplotlib.image as img
# import skimage.transform
# from time import time
import util
if __name__ == '__main__':
fn = util.get_arg('-f', '../data/tom_jerry.jpg', parse_func=str)
print('loading ', fn)
data = io.imread(fn, as_gray=True)
Nx, Ny = data.shape
max_size = 40
# texture-like sampling
# X, Y = np.meshgrid(np.linspace(0, 1, data.shape[0]),
# np.linspace(0, 1, data.shape[1]))
# print(X.shape, Y.shape)
# u = np.array([X.flatten(), Y.flatten(), np.zeros(data.size)]).T
# n_samples = 10000
# v = np.random.random((n_samples, 2))
# y = scipy.interpolate.griddata(u[:, :2], data.T.flatten(), v)
# indices = y.nonzero()
def __init__(self, address_type, kwargs):
self.type = address_type
self.first_name = util.get_arg(kwargs, self.type + '_address_first_name')
self.last_name = util.get_arg(kwargs, self.type + '_address_last_name')
self.line1 = util.get_arg(kwargs, self.type + '_address_line1')
self.line2 = util.get_arg(kwargs, self.type + '_address_line2')
self.line3 = util.get_arg(kwargs, self.type + '_address_line3')
self.city = util.get_arg(kwargs, self.type + '_address_city')
self.state = util.get_arg(kwargs, self.type + '_address_state')
self.country = util.get_arg(kwargs, self.type + '_address_country')
self.postal_code = util.get_arg(kwargs, self.type + '_address_postal_code')
self.phone = util.get_arg(kwargs, self.type + '_address_phone')
self.country_code_iso = util.get_arg(kwargs, self.type + '_address_country_code_iso')
def execute(memory, input):
ptr = 0
result = 0
while ptr < len(memory):
instruction = memory[ptr]
opcode = instruction % 100
modes = instruction // 100
if opcode == 99:
break
if opcode == 1:
arg1 = util.get_arg(memory, ptr, modes, 1)
arg2 = util.get_arg(memory, ptr, modes, 2)
memory[memory[ptr + 3]] = arg1 + arg2
ptr += 4
elif opcode == 2:
arg1 = util.get_arg(memory, ptr, modes, 1)
arg2 = util.get_arg(memory, ptr, modes, 2)
memory[memory[ptr + 3]] = arg1 * arg2
ptr += 4
elif opcode == 3:
memory[memory[ptr + 1]] = input
ptr += 2
elif opcode == 4:
result = util.get_arg(memory, ptr, modes, 1)
ptr += 2
elif opcode == 5:
arg1 = util.get_arg(memory, ptr, modes, 1)
arg2 = util.get_arg(memory, ptr, modes, 2)
ptr = ptr + 3 if arg1 == 0 else arg2
elif opcode == 6:
arg1 = util.get_arg(memory, ptr, modes, 1)
arg2 = util.get_arg(memory, ptr, modes, 2)
ptr = arg2 if arg1 == 0 else ptr + 3
elif opcode == 7:
arg1 = util.get_arg(memory, ptr, modes, 1)
arg2 = util.get_arg(memory, ptr, modes, 2)
memory[memory[ptr + 3]] = int(arg1 < arg2)
ptr += 4
elif opcode == 8:
arg1 = util.get_arg(memory, ptr, modes, 1)
arg2 = util.get_arg(memory, ptr, modes, 2)
memory[memory[ptr + 3]] = int(arg1 == arg2)
ptr += 4
return result
def execute(memory, input):
ptr = 0
base = 0
result = 0
while ptr < len(memory):
instruction = memory[ptr]
opcode = instruction % 100
modes = instruction // 100
if opcode == 99:
break
if opcode == 1:
arg1 = util.get_arg(memory, ptr, modes, 1, base)
arg2 = util.get_arg(memory, ptr, modes, 2, base)
arg3 = util.get_arg(memory, ptr, modes, 3, base, True)
memory[arg3] = arg1 + arg2
ptr += 4
elif opcode == 2:
arg1 = util.get_arg(memory, ptr, modes, 1, base)
arg2 = util.get_arg(memory, ptr, modes, 2, base)
arg3 = util.get_arg(memory, ptr, modes, 3, base, True)
memory[arg3] = arg1 * arg2
ptr += 4
elif opcode == 3:
dst = util.get_arg(memory, ptr, modes, 1, base, True)
memory[dst] = input
ptr += 2
elif opcode == 4:
result = util.get_arg(memory, ptr, modes, 1, base)
ptr += 2
elif opcode == 5:
arg1 = util.get_arg(memory, ptr, modes, 1, base)
arg2 = util.get_arg(memory, ptr, modes, 2, base)
ptr = ptr + 3 if arg1 == 0 else arg2
elif opcode == 6:
arg1 = util.get_arg(memory, ptr, modes, 1, base)
arg2 = util.get_arg(memory, ptr, modes, 2, base)
ptr = arg2 if arg1 == 0 else ptr + 3
elif opcode == 7:
arg1 = util.get_arg(memory, ptr, modes, 1, base)
arg2 = util.get_arg(memory, ptr, modes, 2, base)
arg3 = util.get_arg(memory, ptr, modes, 3, base, True)
memory[arg3] = int(arg1 < arg2)
ptr += 4
elif opcode == 8:
arg1 = util.get_arg(memory, ptr, modes, 1, base)
arg2 = util.get_arg(memory, ptr, modes, 2, base)
arg3 = util.get_arg(memory, ptr, modes, 3, base, True)
memory[arg3] = int(arg1 == arg2)
ptr += 4
elif opcode == 9:
base += util.get_arg(memory, ptr, modes, 1, base)
ptr += 2
return result
return None
def pprint_string(self):
top_bottom = util.color_string('+' + ('-' * self.max_x) + '+',
fore='blue',
back='blue')
side = util.color_string('|', fore='blue', back='blue')
s = ''
for y in range(self.max_y):
s += side + ''.join([Cell.color(c)
for c in self.row(y)]) + side + '\n'
return s + top_bottom
if __name__ == '__main__':
cmd = util.get_arg(1)
if cmd:
if cmd == 'print':
state = State(util.get_arg(2))
util.pprint(state)
elif cmd == 'over':
state = State(util.get_arg(2))
print(state.game_over())
elif cmd == 'winner':
state = State(util.get_arg(2))
print(state.winner())
elif cmd == 'actions':
char = util.get_arg(2)
state = State(util.get_arg(3))
for action in state.actions(char):
print(action)
def remount_greeting(message):
session['have_already_sent_greeting'] = False
session['greeting_message'] = util.get_arg(message.text)
bot.reply_to(message, "Remontado! " + session['greeting_message'])
