def _code_fitness(self, code, codon_usage=None):
""" Gets the overall fitness of a code at the given codon usage,
if no codon usage is given the codon usage of the
currently fixed code at equilibrium is used. """
fitness_contributions = None
if codon_usage is None:
if self._last_messages is None:
if code == self._current_code:
msgs = Messages(self._current_code.effective_code_matrix,
self._fitness_matrix,
self._message_mutation_matrix)
msgs.calculate_at_equilibrium()
self._last_messages = msgs
fitness_contributions = msgs.fitness_contributions
else:
self._code_fitness(self._current_code)
if fitness_contributions is None:
msgs = Messages(code.effective_code_matrix, self._fitness_matrix,
self._message_mutation_matrix)
msgs.calculate_at_codon_usage(self._last_messages.codon_usage)
fitness_contributions = msgs.fitness_contributions
overall_fitness = self._overall_fitness(fitness_contributions)
if codon_usage is None and code == self._current_code:
self._current_code_fitness = overall_fitness
return overall_fitness
def __init__(self, listen_count=None, serv_host=None, serv_port=None):
if listen_count is None:
listen_count = 5
if serv_host is None:
serv_host = 'localhost'
if serv_port is None:
serv_port = 3490
# set server messages worker
self.MsgWorker = Messages(host=serv_host,
port=serv_port,
backlog=listen_count)
# set data base worker
self.DbWorker = DbHandler()
# set command worker
self.CmdWorker = Commands()
self.uid_link = {}
self.user_list = []
self.server_password = '******'
# initialize server socket
self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.server.bind((serv_host, serv_port))
self.server.listen(listen_count)
print(self.MsgWorker.welcome_string())
# set signal handler
signal.signal(signal.SIGINT, self.sighandler)
def __init__(self, access_token=''):
self.Account = Account(access_token=access_token)
self.Apps = Apps(access_token=access_token)
self.Audio = Audio(access_token=access_token)
self.Auth = Auth(access_token=access_token)
self.Board = Board(access_token=access_token)
self.Database = Database(access_token=access_token)
self.Docs = Docs(access_token=access_token)
self.Other = Other(access_token=access_token)
self.Fave = Fave(access_token=access_token)
self.Friends = Friends(access_token=access_token)
self.Gifts = Gifts(access_token=access_token)
self.Groups = Groups(access_token=access_token)
self.Likes = Likes(access_token=access_token)
self.Market = Market(access_token=access_token)
self.Messages = Messages(access_token=access_token)
self.Newsfeed = Newsfeed(access_token=access_token)
self.Notes = Notes(access_token=access_token)
self.Notifications = Notifications(access_token=access_token)
self.Pages = Pages(access_token=access_token)
self.Photos = Photos(access_token=access_token)
self.Places = Places(access_token=access_token)
self.Polls = Polls(access_token=access_token)
self.Search = Search(access_token=access_token)
self.Stats = Stats(access_token=access_token)
self.Status = Status(access_token=access_token)
self.Storage = Storage(access_token=access_token)
self.Users = Users(access_token=access_token)
self.Utils = Utils(access_token=access_token)
self.Video = Video(access_token=access_token)
self.Wall = Wall(access_token=access_token)
self.Widgets = Widgets(access_token=access_token)
def download_song(self, metadata):
dl_url = metadata['dl_url']
timestamp = int(time())
fn = [
'bctcache',
str(timestamp), metadata['artist_id'], metadata['track_id']
]
filename = '_'.join(fn) + '.mp3'
path = os.path.join(c['cache_dir'], filename)
# If exists, load, if not dl
rel_path = c['cache_dir'].split('/')[-1]
local_path = rel_path + '/' + filename
if os.path.isfile(path) is True:
MPDQueue.add_song(local_path)
else:
try:
r = requests.get(dl_url, stream=dl_url, headers=HEADERS)
except requests.exceptions.RequestException as e:
print(e)
quit()
Messages().now_loading(metadata['artist'], metadata['track'])
with open(path, 'wb') as t:
total_length = int(r.headers.get('content-length', 0))
for chunk in progress.bar(r.iter_content(chunk_size=1024),
expected_size=(total_length / 1024) +
1):
if chunk:
t.write(chunk)
t.flush()
self.write_ID3_tags(filename, metadata)
MPDQueue().add_song(local_path)
def setUp(self):
self.mutation_matrix = np.array(
[[0.96, 0.02, 0., 0., 0., 0., 0., 0.02],
[0.02, 0.96, 0.02, 0., 0., 0., 0., 0.],
[0., 0.02, 0.96, 0.02, 0., 0., 0., 0.],
[0., 0., 0.02, 0.96, 0.02, 0., 0., 0.],
[0., 0., 0., 0.02, 0.96, 0.02, 0., 0.],
[0., 0., 0., 0., 0.02, 0.96, 0.02, 0.],
[0., 0., 0., 0., 0., 0.02, 0.96, 0.02],
[0.02, 0., 0., 0., 0., 0., 0.02, 0.96]])
pchem_vals = [
0.05, 0.15, 0.24, 0.41, 0.44, 0.51, 0.54, 0.79, 0.83, 0.92
]
site_ids = range(10)
aa_ids = range(10)
self.site_types = Ring_Site_Types(.25, zip(aa_ids, pchem_vals),
zip(site_ids, pchem_vals), [1] * 10)
self.code_matrix = np.ones((8, 10)) / 10
self.fitness_contributions = None
self.message = Messages(self.code_matrix,
self.site_types.fitness_matrix,
self.mutation_matrix)
def __init__(self, clientId, accessCode=None):
self.__channelNames = ChannelNames(clientId)
self.__messages = Messages(clientId, accessCode)
self.__listeners = []
self.__connected = False
self.__connection = None
self.__channel = None
self.__clientId = clientId
def __init__(self, config, queue, markets, api):
self.config = config
self.markets = markets
self.api = api
self.best_ask_bid = BestAskBidAdapter(queue, 'spot_trading','weekly','biweekly','3month')
self.trade_pairs = TradePairs()
self.trade = Trade(self.api, config, markets)
self.scheduler = Scheduler(self.config, self.markets)
self.messages = Messages(self.config.config_data['message_language'])
def __init__(self, host, port, vk, sk):
threading.Thread.__init__(self)
self.messages = Messages()
self.mailbox = Mailbox(host, port, timeout=None)
self.vk = vk
self.sk = sk
self.session = None
self.number = None
self.number_of_players = None
self.players = {}
def __init__(self, page):
self.page = page
self.conf = conf.getInstance()
messageLikes_addHeaders(page)
messageComments_addHeaders(page)
self.messages = Messages()
self.scroll_pos = 0
self.num_messages = None
self.url_preview_html = unicode(open('url_preview.html').read())
def options_menu(self, current_song, change_state):
""" Render options menu and handle commands """
change = change_state
term = Terminal()
with term.location(0, term.height - 1):
with term.cbreak():
c = term.inkey(1)
if c == 't':
change = 'to_tag'
if c == 'u':
print(term.clear())
change = 'to_user'
if c == 'q':
print(term.clear())
print(term.normal)
self.clear_cache()
exit()
if c == 'B':
ar_id = current_song.split('_')[3]
self.ban(ar_id, 0)
show = 'Banning artist'
Messages().menu_choice(show)
if c == 'b':
tr_id = current_song.split('_')[4].replace('.mp3', '')
self.ban(tr_id, 1)
show = 'Banning song'
Messages().menu_choice(show)
if c == 's':
show = f"Saving info to {cf['save_file']}"
Messages().menu_choice(show)
self.save_track_info(current_song)
if c == 'w':
try:
EasyID3(os.path.join(cf['music_dir'],
current_song))['website'][0]
show = 'Opening Bandcamp page'
Messages().menu_choice(show)
self.browser(current_song)
except BaseException:
print("No website saved in track meta.")
time.sleep(2)
print(term.clear())
return change
def __init__(self, newclass=False, ismessages=False, comments=False, configure=None,\ construct=None): self.configure = None if configure != None: self.configure = self._load_configure(configure) else: self.newclass = newclass self.comments = comments self.messages = Messages(ismessages) self.construct = construct
def get_albums(self):
""" Get urls of random albums. """
# Max page number is 30
if self.page_limit:
self.page = random.randint(1, int(self.page_limit))
else:
self.page = random.randint(
1, 3) if not self.page else random.randint(self.page, 30)
if self.page_limit and self.page_limit < 3:
Messages().few_tag_results(self.tag)
while True:
ar = self.call_album_api()
items = ar.get('items', None)
self.has_more = ar.get('more-available', None)
if not items:
self.page = abs(self.page - 1)
continue
if 'items' in ar and len(ar['items']) > 0:
if self.has_more is False:
# Response has items but no more available, so mark page limit
self.page_limit = self.page
break
else:
continue
Messages().results_found(self.tag)
albums = []
genres = []
for i in ar['items']:
albums.append(i['tralbum_url'])
genres.append(i['genre'])
all_tags = genres + list(self.related_tags)
random.shuffle(all_tags)
at = all_tags[:10]
if not self.related_tags:
self.related_tags = genres
else:
self.related_tags = set([a for a in at if a]) if at else genres
Messages().related_tags(', '.join(set(self.related_tags)))
self.get_song_meta(set(albums))
def __init__ (self, collKey, db): UserDict.__init__(self) self.name = db.name messages = Messages (db, collKey) for msg in messages: id = msg['id'] if not self.has_key (id): self[id] = [] val = self[id] val.append (msg) self[id] = val
def __init__(self):
auth = tweepy.OAuthHandler(auth_dict['CONSUMER_KEY'],
auth_dict['CONSUMER_SECRET'])
auth.set_access_token(auth_dict['ACCESS_TOKEN'],
auth_dict['ACCESS_TOKEN_SECRET'])
self.OWNER = auth_dict['OWNER']
self.OWNER_ID = auth_dict['OWNER_ID']
self.API = tweepy.API(auth, wait_on_rate_limit=True)
self.path = pathlib.PurePath(os.getcwd())
self.msg = Messages()
def getMessages():
messages = Messages()
if request.method == 'POST':
if request.data:
# Content-Type: application/json
# ie. - { "foo": "bar", "baz": "moe" }
data = json.loads(request.data)
else:
# Content-Type: x-www-form-urlencoded
# ie. - foo=bar&baz=moe
data = dict((k, request.values[k]) for k in request.values.keys())
return jsonify(messages.add(data))
else:
return jsonify(messages.getMessages())
def __init__(self):
self.settings = Settings()
self.messages = Messages()
self.laskin = Laskin(self.settings, self.messages)
self.mehilaispesa = Mehilaispesa(self.messages, self.laskin)
self.datahallinta = DataHallinta(self.settings, self.messages)
self.kirjoitin = BeeWriter(self.settings, self.messages,
self.mehilaispesa)
self.ryhmakirjoitin = GroupWriter(self.settings, self.messages,
self.mehilaispesa)
self.dataluku = Dataluku(self.settings, self.messages,
self.mehilaispesa, self.datahallinta)
def __init__(self, url, channel, queue=None, config=None):
self.url = url
self.channel = channel
self.queue = queue
self.config = config
self.messages = Messages(self.config.config_data['message_language'])
self.ws = websocket_rev.WebSocketApp(self.url,
header=None,
on_open=self.on_open,
on_message=self.on_message,
on_error=self.on_error,
on_close=self.on_close)
#define websocket
websocket_rev.enableTrace(True)
self.is_running = True
def __init__(self, parent):
self.parent = parent
self.device = parent.device
self.data_layer = parent.data_layer
self.apps = parent.apps
self.marionette = parent.marionette
self.actions = Actions(self.marionette)
# Globals used for reporting ...
self.errNum = 0
self.start_time = time.time()
# Get run details from the OS.
self.general = general(self)
self.test_num = parent.__module__[5:]
self.app = app(self)
self.date_and_time = date_and_time(self)
self.debug = debug(self)
self.element = element(self)
self.home = home(self)
self.iframe = iframe(self)
self.messages = Messages(self)
self.network = network(self)
self.reporting = reporting(self)
self.statusbar = statusbar(self)
self.test = test(self)
self.visual_tests = visualtests(self)
self.marionette.set_search_timeout(10000)
self.marionette.set_script_timeout(10000)
elapsed = time.time() - self.start_time
elapsed = round(elapsed, 0)
elapsed = str(datetime.timedelta(seconds=elapsed))
self.reporting.debug(
"Initializing 'UTILS' took {} seconds.".format(elapsed))
current_lang = parent.data_layer.get_setting("language.current").split(
'-')[0]
self.reporting.info(
"Current Toolkit language: [{}]".format(current_lang))
try:
btn = self.marionette.find_element('id', 'charge-warning-ok')
btn.tap()
except:
pass
parent.data_layer.set_setting('screen.automatic-brightness', True)
def __init__(self):
self.__messages = Messages()
self.__prev_position = None
self.__prev_timestamp = time.time()
self.__timer = 5
self.__screen_size = pyautogui.size()
print("Screen Resolution: %sx%s" %
(self.__screen_size[0], self.__screen_size[1]))
self.__dead_zone_point = (self.__screen_size[0] / 2,
self.__screen_size[1] / 2)
self.__dead_zone_radius = 50 # In pixels
self.__keyboard = keyboard.add_hotkey(hotkey="ctrl+m",
callback=self.move_to_dead_zone)
self.__debug = False
self.__keyboard = keyboard.add_hotkey(hotkey="ctrl+d",
callback=self.switch_debug)
self.__keyboard = keyboard.add_hotkey(
hotkey="ctrl+p", callback=self.move_to_dead_zone_point)
def clientThread(self, conn, addr, buffsize):
msgs = Messages()
while True:
try:
message = conn.recv(buffsize)
if message:
msgs.packets.ParseFromString(message[:-3])
session = msgs.get_session()
number = msgs.get_number()
from_key = msgs.get_from_key()
to_key = msgs.get_to_key()
if session == '' and number == 0 and from_key != '':
if not self.pool[addr]['key']:
self.pool[addr]['key'] = from_key
msgs.clear_packets()
msgs.packets.packet.add()
msgs.packets.packet[-1].packet.session = self.pool[
addr]['session']
msgs.packets.packet[-1].packet.number = self.pool[
addr]['number']
msg = msgs.packets.SerializeToString() + self.frame
conn.send(msg)
# time.sleep(1)
if len([
1 for address in self.pool
if self.pool[address]['key']
]) == self.number_of_players:
msgs.clear_packets()
msgs.packets.packet.add()
msgs.packets.packet[-1].packet.phase = 1
msgs.packets.packet[
-1].packet.number = self.number_of_players
self.broadcast_message(
msgs.packets.SerializeToString() +
self.frame)
if session != '' and number != 0 and from_key != '' and to_key == '':
self.broadcast_message(message)
if session != '' and number != 0 and from_key != '' and to_key != '':
self.unicast_message(message, to_key)
else:
pass
except Exception as e:
continue
def run_game():
# Initialize pygame, settings and screen object
pygame.init()
settings = Settings()
screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
pygame.display.set_caption("BREAKOUT clone by Cameron Tee")
#Instantiate GameStats, Scoreboard and Messages
stats = GameStats(settings)
sb = Scoreboard(settings, screen, stats)
msg = Messages(settings, screen)
#Make the paddle, ball and group of bricks
paddle = Paddle(settings, screen)
ball = Ball(settings, screen, paddle)
bricks = Group()
#Creates a 'wall' (rows and columns) of bricks
gf.build_wall(settings, screen, bricks)
#Clock controlling the frequency of the screen updates
clock = pygame.time.Clock()
#Begin the main loop for the game
while True:
gf.check_events(paddle, ball, bricks, screen, settings, sb, stats, msg)
#Player should be able to move around the paddle before releasing the ball
if not stats.game_active:
paddle.update()
ball.center_ball(paddle)
if stats.game_active:
paddle.update()
ball.update(paddle)
gf.update_lives(paddle, ball, bricks, settings, screen, sb, stats)
gf.update_bricks(bricks, ball, screen, settings, sb, stats)
gf.update_screen(settings, screen, paddle, ball, bricks, sb, stats,
msg)
#At most 120 frames will pass per second
clock.tick(120)
def test_000_server_conncetion(self):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST,PORT))
session = None
number = None
msgs = Messages()
pack = msgs.packets.packet.add()
pack.packet.from_key.key = 'some key for test'
request = msgs.packets.SerializeToString() + framing_end
s.sendall(request)
response = s.recv(2048)
msgs.packets.ParseFromString(response[:-3])
self.assertIsInstance(msgs.packets, message_factory.Packets)
session = msgs.packets.packet[-1].packet.session
number = msgs.packets.packet[-1].packet.number
self.assertIsNotNone(session)
self.assertIsNotNone(number)
self.assertIsInstance(session,str)
self.assertIsInstance(number,int)
self.assertTrue(len(session)>0)
self.assertTrue(number > 0)
def __init__(self, host, port, vk, amount, fee, sk, addr_new, change):
threading.Thread.__init__(self)
self.messages = Messages()
self.income = Channel()
self.outcome = Channel()
self.logger = ChannelWithPrint()
self.commutator = Commutator(self.income,
self.outcome,
logger=self.logger)
self.vk = vk
self.session = None
self.number = None
self.number_of_players = None
self.players = {}
self.amount = amount
self.fee = fee
self.sk = sk
self.addr_new = addr_new
self.change = change
self.deamon = True
self.commutator.connect(host, port)
def runBot():
loop = asyncio.get_event_loop()
theClient = bot.BotClient()
commands = Commands(theClient)
#levels = UserLevels(theClient)
scrape = Scrape(theClient)
saved = SaveLinks(theClient)
messages = Messages(theClient)
coins = Coins(theClient)
try:
loop.run_until_complete(theClient.start(Token))
except KeyboardInterrupt:
loop.run_until_complete(theClient.close())
finally:
loop.close()
if theClient.restart == True:
if asyncio.get_event_loop().is_closed():
asyncio.set_event_loop(asyncio.new_event_loop())
reload(bot)
runBot()
def run_game():
"""
Initializes the pygame module and instantiates all the game elements.
While loop controls what functions are called based on the conditions
of the game (lives left and the game state).
"""
pygame.init()
settings = Settings()
screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
pygame.display.set_caption("Flappy Bird clone by Cameron Tee")
background = BackGround(screen)
ground = Ground(screen, settings)
stats = GameStats(settings)
sb = Scoreboard(screen, settings, stats)
msgs = Messages(screen, settings)
bird = Bird(screen, settings, stats)
pipes = []
clock = pygame.time.Clock()
while True:
gf.check_events(screen, settings, bird, pipes, sb, stats, msgs)
if not stats.game_active and stats.lives_left > 0:
gf.centre_bird(screen, bird)
if stats.game_active:
gf.collision_check(screen, settings, bird, pipes, stats)
gf.update_pipes(screen, settings, bird, pipes, sb, stats)
gf.update_screen(screen, settings, background, ground, bird, pipes, sb,
stats, msgs)
clock.tick(100)
async def _run(self):
""" Main program """
# Create channels from database
try:
loop = asyncio.get_event_loop()
signals = (signal.SIGHUP, signal.SIGTERM, signal.SIGINT)
for s in signals:
cur_task = asyncio.current_task()
loop.add_signal_handler(s, lambda s=s: asyncio.create_task(exit_safe(s, cur_task)))
except NotImplementedError:
# Signal are not implemented on this platform (i.e.: windows), so do'nt use it
pass
try:
upd = UpdateChannels(self._database)
ch_list = upd.channels()
self.engine = Engine(ch_list)
task_msg = asyncio.create_task(self.send_channel_state(self.engine.get_event_new_state()))
self.messages = Messages(subkey=self.config['messages']['pubnub_subkey'],
pubkey=self.config['messages']['pubnub_pubkey'],
id=self.config['messages']['id'])
except Exception:
self.logger.info("FATAL ERROR", exc_info=True)
sys.exit(1)
keep_running = True
# Main loop
while keep_running:
try:
# Blocking call until a new message is present or stop event
msg = await self.messages.get_message()
try:
p = cmdparser.Parser(msg)
if p.get_command() == 'get program':
data = self._database.read()
await self.messages.send(data)
elif p.get_command() == 'force channel':
nb = p.get_param()['nb']
action = p.get_param()['action']
duration = p.get_param()['duration']
self.engine.channel_forced(nb, action, duration)
await self.messages.send({"status": "OK"})
elif p.get_command() == 'new program' or p.get_command() == 'new channel':
program = p.get_param()['program']
if p.get_command() == 'new program':
self._database.write(program)
else:
self._database.update_channels(program)
upd = UpdateChannels(self._database)
ch_list = upd.channels()
self.engine.stop()
task_msg.cancel()
self.engine = Engine(ch_list)
task_msg = asyncio.create_task(self.send_channel_state(self.engine.get_event_new_state()))
await self.messages.send({"status": "OK"})
elif p.get_command() == 'get channels state':
await self.messages.send({"channelstate": self.engine.get_channel_state()})
except BaseException:
self.logger.warning(f"Received unknown message: {json.loads(msg)}", exc_info=True)
except asyncio.CancelledError:
keep_running = False
task_msg.cancel()
if self.engine is not None:
self.engine.stop()
if self.messages is not None:
self.messages.stop()
self.logger.info("Sprinkler program is stopped")
def __init__(self, config, markets):
self.swap_point_rate = config.config_data['swap_point_rate']
self.markets = markets
self.messages = Messages(config.config_data['message_language'])
from aiogram import Bot, types
from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
from aiogram.dispatcher import Dispatcher
from aiogram.utils import executor
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from aiogram.types.message import ContentTypes
from messages import Messages
import sqlite3
import markups
import config
import asyncio
messages = Messages()
bot = Bot(token=config.token)
dp = Dispatcher(bot, storage=MemoryStorage())
# Преобразовние корзины из строки в словарь
def make_dict(text: str):
if text[0] == ' ':
text = text[1::]
conn = sqlite3.connect("data.db")
cursor = conn.cursor()
temp = text.split()
result = {}
for product in temp:
count = product.split('__')[1]
product = product.split('__')[0]
cursor.execute('''SELECT * FROM products WHERE name = ?''', (product,))
fetchall = cursor.fetchall()
def __init__(self, api, config, markets):
self.api = api
self.scheduler = Scheduler(config, markets)
self.messages = Messages(config.config_data['message_language'])
ui.btn_cnpj.clicked.connect(mostra_dialogCnpj)
dialog_cnpj_padrao.btn_ok.clicked.connect(confirma_cnpj_padrao)
dialog_cnpj_padrao.btn_cancel.clicked.connect(Dialog_Cnpj.reject)
ui.txt_num_notas.setValidator(
QtGui.QIntValidator(constant.MIN_NOTAS, constant.MAX_NOTAS))
ui.txt_num_notas.setText(str(constant.DEFAULT_NUMERO_NOTAS))
ui.txt_cnpj_estab.setText(constant.EMPTY_STR)
servico_posting = Posting()
ui.btn_postar.clicked.connect(on_abre_postar)
m = Messages()
lista_notas = []
lista_cnpj = []
mes_tipo = 1 #mes atual
mes_sel = define_mes_padrao()
mes_sel_int = define_mes_padrao_int()
if constant.INICIA_DB_INICIO:
init_db()
#cria lista (notas e empresas)
cria_tabela_notas()
cria_tabela_empresas()
