def __init__(self, clock, controller):
self._current = None
clock.subscribe(self.tick)
controller.subscribe(self.input_changed)
self.set_screen(
(config.getint('Graphics',
'width'), config.getint('Graphics', 'height')))
def new_level(self, level_no=None):
if level_no is None:
self.current += 1
else:
self.current = level_no
screen_width, screen_height = config.getint('Graphics','width'), config.getint('Graphics', 'height')
self.level = Level(self.levels[self.current], screen_width, screen_height)
def on_init(self):
self.ticker = self.contract.ticker
log.msg("Engine for contract %s (%d) started." % (self.ticker, self.contract.id))
log.msg(
"Listening for connections on port %d." % (config.getint("engine", "accountant_base_port") + self.contract.id))
log.msg(
"Listening for connections on port %d." % (config.getint("engine", "administrator_base_port") + self.contract.id))
def collide_walls(self, ms):
grounded = False
for layer in self.world_map.layers:
if layer.is_object_group:
continue
floor_tile = None
for pos in self.player.bottom_collide_pts:
tile = self.get_tile(pos, layer)
if tile:
# Move above this tile.
# This assumes we are not completely overlapping a tile.
# This should never happen if we limit movement to < 16px per frame
floor_tile = tile
self.player.displace(0, -(self.player.collide_rect.bottom % 16))
grounded = True
break
if floor_tile:
self.tile_magic(floor_tile)
if floor_tile == config.getint('Tiles', 'crack') and self.player.heavy:
self.set_platform(pos, layer, config.getint('Tiles', 'break'))
elif floor_tile == config.getint('Tiles', 'break') and self.player.heavy:
self.set_platform(pos, layer, 0)
# All floor tiles stop the players fall
self.player.velocity = (self.player.velocity[0],0)
top_points = self.player.top_collide_pts
for pos in top_points:
if grounded: break
if self.get_tile(pos, layer):
debug('collide top %s', pos)
self.player.displace(0, 16) # move one tile down
self.player.displace(0, -(self.player.collide_rect.top % 16)) # move to the top of the tile
self.player.velocity = (self.player.velocity[0],0)
break
left_points = self.player.left_collide_pts
for pos in left_points:
if self.get_tile(pos, layer):
debug('collide left %s', pos)
self.player.displace(16, 0)
self.player.displace(-(self.player.collide_rect.left % 16), 0)
break
right_points = self.player.right_collide_pts
for pos in right_points:
if self.get_tile(pos, layer):
debug('collide right %s', pos)
debug(self.get_tile(pos,layer))
self.player.displace(-(self.player.collide_rect.right % 16), 0)
break
# Update the jump timer which determines if it's possible to jump
if grounded:
self.jump_timer.set()
else:
self.jump_timer.update(ms)
def __init__(self, levels, director, next_scene=None):
object.__init__(self)
self.levels = levels
self.current = 0
self.next_scene = next_scene
self.director = director
screen_width, screen_height = config.getint('Graphics','width'), config.getint('Graphics', 'height')
self.level = Level(self.levels[self.current], screen_width, screen_height)
def main():
# initialize the configuration
config.main()
# create the mandatory wx application object
app = wx.App(redirect=False)
# test for availability of our listening port
interface = config.get('client', 'listen_interface')
port = config.getint('client', 'listen_port')
log.info('opening TorChat listener on %s:%s' % (interface, port))
listen_socket = tc_client.tryBindPort(interface, port)
if not listen_socket:
log.info('%s:%s is already in use' % (interface, port))
wx.MessageBox(tc_gui.lang.D_WARN_USED_PORT_MESSAGE % (interface, port),
tc_gui.lang.D_WARN_USED_PORT_TITLE)
return
else:
log.info('TorChat is listening on %s:%s' % (interface, port))
# now continue with normal program startup
log.info('start initializing main window')
app.mw = tc_gui.MainWindow(listen_socket)
app.SetTopWindow(app.mw)
log.info('main window initialized')
log.info('entering main loop')
app.MainLoop()
def tick(self, ms):
self.player.move(ms)
if self.player.collide_rect.left >= self.world_map.pixel_width - 16:
debug('Level complete')
return True
# Handle collisions with walls/platforms
try:
self.collide_walls(ms)
except OutOfBounds:
debug('%s out of bounds', self.player.collide_rect)
raise FellOffMap()
# Check for jump every frame, in case user is holding down the button
if not self.jump_wait_timer and self.input_state and self.input_state['up'] and self.jump_timer.jump_allowed():
debug('jump')
self.jump_timer.unset()
self.jump_wait_timer = Timer(config.getint('Physics','jump_wait_time')) # wait a bit between jumps
self.player.start_jump()
elif self.jump_wait_timer:
if self.jump_wait_timer.check(ms):
self.jump_wait_timer = None
# Center camera on player
self.camera.center = self.player.rect.center
# Constrain camera to the level
self.camera.right = min(self.camera.right, self.world_map.pixel_width)
self.camera.bottom = min(self.camera.bottom, self.world_map.pixel_height)
self.camera.left = max(self.camera.left, 0)
self.camera.top = max(self.camera.top, 0)
self.renderer.set_camera_position(self.camera.centerx, self.camera.centery)
self.renderer.set_camera_margin(0, 0, 0, 0) # something is resetting the margin to 16px each frame... grrr
def tile_magic(self, tile, allow_break=True):
'''Handle special tiles'''
#debug(tile)
for special_tile in ('grow', 'shrink', 'narrow', 'widen'):
if config.getint('Tiles', special_tile) == tile:
getattr(self.player, special_tile)()
return
def resize(img, index, component):
saved = []
# Numpy-Array in Pillow einlesen
im = Image.fromarray(np.uint8(img), 'L')
scale = config.getint('SCALE_FACTOR')
# im = Image.open("../data/processed/cropped37.jpg").convert("L")
width, height = im.size
width *= scale
height *= scale
angle = 180
# Bild um Faktor skalieren und ANTIALIAS als Interpolationsmethode wählen
im = im.resize((width, height), Image.ANTIALIAS)
if height > width:
im = im.rotate(-90, expand=1)
angle = 90
img = np.array(im)
# Bild optimieren
thresh = threshold_otsu(img)
img = img > 127
#print("Saving to: ", config.get('RESULT_PATH') + index + "_optimized.jpg")
plt.imsave(config.get('RESULT_PATH') + index + "_optimized.png",
img,
cmap=cm.gray)
# Optimiertes Bild abspeichern
saved.append((index + "_optimized.png", component, angle))
return saved
def calculate_clusters(center_points):
arr = np.array(list(center_points.values()))
# DBSCAN Clustering auf center points der Komponenten anwenden
# siehe: http://scikit-learn.org/stable/auto_examples/cluster/plot_dbscan.html#sphx-glr-auto-examples-cluster-plot-dbscan-py
db = DBSCAN(eps=config.getint('EPS'),
min_samples=config.getint('MIN_SAMPLES')).fit(arr)
core_samples_mask = np.zeros_like(db.labels_, dtype=bool)
core_samples_mask[db.core_sample_indices_] = True
labels = db.labels_
# Anzahl Cluster für Debugging berechnen
n_clusters = len(set(labels)) - (1 if -1 in labels else 0)
#print(labels)
return labels
def player_set_variables_from_config(self):
"""Initialize user settings from the configuration storage"""
for key, vdict in INT_SETTINGS.items():
try:
setattr(self, key,
config.getint("plugins", "autoqueue_%s" % key))
except:
setattr(self, key, vdict['value'])
config.set("plugins", "autoqueue_%s" % key, vdict['value'])
for key, vdict in BOOL_SETTINGS.items():
try:
setattr(
self, key,
config.get("plugins",
"autoqueue_%s" % key).lower() == 'true')
except:
setattr(self, key, vdict['value'])
config.set("plugins", "autoqueue_%s" % key,
vdict['value'] and 'true' or 'false')
for key, vdict in STR_SETTINGS.items():
try:
setattr(self, key, config.get("plugins", "autoqueue_%s" % key))
except:
setattr(self, key, vdict['value'])
config.set("plugins", "autoqueue_%s" % key, vdict['value'])
def main():
# initialize the configuration
config.main()
# create the mandatory wx application object
app = wx.App(redirect=False)
# test for availability of our listening port
interface = config.get('client', 'listen_interface')
port = config.getint('client', 'listen_port')
log.info('opening TorChat listener on %s:%s' % (interface, port))
listen_socket = tc_client.tryBindPort(interface, port)
if not listen_socket:
log.info('%s:%s is already in use' % (interface, port))
wx.MessageBox(tc_gui.lang.D_WARN_USED_PORT_MESSAGE
% (interface, port),
tc_gui.lang.D_WARN_USED_PORT_TITLE)
return
else:
log.info('TorChat is listening on %s:%s' % (interface, port))
# now continue with normal program startup
log.info('start initializing main window')
app.mw = tc_gui.MainWindow(listen_socket)
app.SetTopWindow(app.mw)
log.info('main window initialized')
log.info('entering main loop')
app.MainLoop()
def main():
print "(2) wxPython version %s" % wx.version()
#create the mandatory wx application object
if config.isMac():
import tc_mac
app = tc_mac.App(redirect=False)
else:
app = wx.App(redirect=False)
#test for availability of our listening port
interface = config.get("client", "listen_interface")
port = config.getint("client", "listen_port")
print "(1) opening TorChat listener on %s:%s" % (interface, port)
listen_socket = tc_client.tryBindPort(interface, port)
if not listen_socket:
print "(1) %s:%s is already in use" % (interface, port)
wx.MessageBox(tc_gui.lang.D_WARN_USED_PORT_MESSAGE % (interface, port),
tc_gui.lang.D_WARN_USED_PORT_TITLE)
return
else:
print "(1) TorChat is listening on %s:%s" % (interface, port)
#now continue with normal program startup
print "(1) start initializing main window"
app.mw = tc_gui.MainWindow(listen_socket)
app.SetTopWindow(app.mw)
print "(1) main window initialized"
print "(1) entering main loop"
app.MainLoop()
def _extract_params():
params = {'storage_duration': '12H'}
for name, default_value in params.items():
if not config.has_option('database', name):
service_logger.warning("Not found '{name}' in database section, using default value: '{default_value}'."
.format(name=name, default_value=default_value))
value = default_value
else:
value = config.get('database', name)
params[name] = value
params['database_dir'] = config.get('database', 'database_dir')
params['listen_host'] = config.get('server', 'listen_host')
params['listen_port'] = config.getint('server', 'listen_port')
params['white_host'] = config.get('server', 'white_host')
params['white_port'] = config.get('server', 'white_port')
# Https configures.
if config.has_option('security', 'tls') and config.getboolean('security', 'tls'):
params['server_cert'] = config.get('security', 'server_cert')
params['server_key'] = config.get('security', 'server_key')
params['ca'] = config.get('security', 'ca')
with open(os.path.join(global_vars.CURRENT_DIRNAME, 'certificate/pwf'),
mode='r') as f:
params['cert_pwd'] = f.read().strip()
return params
def callbackMessage(self, callback_type, callback_data):
#we must always use wx.CallAfter() to interact with
#the GUI-Thread because this method will be called
#in the context of one of the connection threads
if callback_type == tc_client.CB_TYPE_CHAT:
buddy, message = callback_data
for window in self.chat_windows:
if window.buddy == buddy:
return
#no window found, so we create a new one
#we let this thread block until the window
#shows up in our chat window list
found = False
while not found:
time.sleep(1)
print 'TEST TEST'
for window in self.chat_windows:
if window.buddy == buddy:
found = True
break
if callback_type == tc_client.CB_TYPE_OFFLINE_SENT:
buddy = callback_data
for window in self.chat_windows:
if window.buddy == buddy:
return
hidden = config.getint("gui", "open_chat_window_hidden")
if callback_type == tc_client.CB_TYPE_FILE:
receiver = callback_data
buddy = receiver.buddy
file_name = receiver.file_name
def main():
load_plugins()
global app
print "(2) wxPython version %s" % wx.version()
#create the mandatory wx application object
if config.isMac():
import tc_mac
app = tc_mac.App(redirect=False)
else:
app = wx.App(redirect=False)
#test for availability of our listening port
interface = config.get("client", "listen_interface")
port = config.getint("client", "listen_port")
print "(1) opening TorChat listener on %s:%s" % (interface, port)
listen_socket = tc_client.tryBindPort(interface, port)
if not listen_socket:
print "(1) opening TorChat listener on %s, any port" % interface
listen_socket = tc_client.tryBindPort(interface, 0)
if not listen_socket:
print "(1) %s:%s is already in use" % (interface, port)
wx.MessageBox(tc_gui.lang.D_WARN_USED_PORT_MESSAGE % (interface, port),
tc_gui.lang.D_WARN_USED_PORT_TITLE)
return
else:
print "(1) TorChat is listening on %s:%s" % (interface, port)
#now continue with normal program startup
print "(1) start initializing main window"
app.mw = tc_gui.MainWindow(listen_socket)
app.SetTopWindow(app.mw)
print "(1) main window initialized"
print "(1) entering main loop"
app.MainLoop()
def set_config(config):
envName = "Environment Values"
AHit.goal_x = config.getint(envName, "goal_x")
AHit.goal_y = config.getint(envName, "goal_y")
AHit.goal_z = config.getint(envName, "goal_z")
AHit.shot_off_x = config.getint(envName, "shot_off_x")
AHit.shot_off_z = config.getint(envName, "shot_off_z")
AHit.magic_vel = config.getfloat(envName, "magic_vel")
APosition.magic_vel = config.getfloat(envName, "magic_vel")
magic_vel = 0.0043527
AHit.normal_g = config.getfloat(envName, "normal_g")
AHit.cutoff_time_to_goal = config.getfloat("Shot Detection", "cutoff_time_to_goal")
def buildUUIDCache():
log.log(log.DEBUG, 'Building UUID cache')
listing = os.listdir(config.get('archive', 'uuid_dir'))
for file in listing:
st = os.stat(config.get('archive', 'uuid_dir') + '/' + file)
notifier.uuidcache.append( (file, st[9]) ) # ctime
notifier.uuidcache.sort()
notifier.uuidcache = notifier.uuidcache[:config.getint('notify-atom', 'feedlength')]
def get_random_sc_urls():
urls = []
for station in database.ShoutcastStation.select():
urls.append('%s?id=%s' % (SC_TUNE_URL, station.scid))
random.shuffle(urls)
return urls[0:config.getint('server', 'urls_per_request')]
def getBaseConnectionArgsDict():
"""Return a dictonary of common database connection arguments."""
return {
"host": config.get("repository", "host"),
"port": config.getint("repository", "port"),
"user": config.get("repository", "user"),
"passwd": config.get("repository", "passwd"),
"charset": "utf8",
"use_unicode": True,
}
def setUpClass(cls):
cls.autostacksApp = TestApp(autostacks_api.app.wsgifunc())
cls.cloudwatchApp = TestApp(cloudwatch_api.app.wsgifunc())
cls.customApp = TestApp(custom_api.app.wsgifunc())
cls.instancesApp = TestApp(instances_api.app.wsgifunc())
cls.modelApp = TestApp(models_api.app.wsgifunc())
cls.headers = getDefaultHTTPHeaders(htm-it.app.config)
cls.plaintextPort = config.getint("metric_listener", "plaintext_port")
cls.apiKey = config.get("security", "apikey")
def getMessage(sock):
log.log(log.DEBUG, 'Receiving message from socket')
msg = ''
buf = ''
while buf != 0:
buf = sock.recv(config.getint('general', 'recvbuffer'))
msg += buf
if msg[-2:] == '\n\n':
return msg
return msg
def get_lines(img):
img = rgb2grey(img)
thresh = threshold_mean(img)
img = img <= thresh
# http://scikit-image.org/docs/dev/auto_examples/edges/plot_line_hough_transform.html
fig, axes = plt.subplots(1, 2)
ax = axes.ravel()
ax[0].imshow(img)
ax[1].imshow(img, cmap=cm.gray)
# Linien mittels Probalistischer-Hough-Transformation erkennen
lines = probabilistic_hough_line(
img,
threshold=config.getint('HOUGH_THRESHOLD'),
line_length=config.getint('HOUGH_LINE_LENGTH'),
line_gap=config.getint('HOUGH_LINE_GAP'))
# Erlaubte Winkel definieren
allowed_values = [-180, -90, 90, 180]
relevant_lines = []
relevant_lines_no_angle = []
ax[1].imshow(img * 0)
for line in lines:
p0, p1 = line
# Winkel der Geraden berechnen
# http://wikicode.wikidot.com/get-angle-of-line-between-two-points
angle = degrees(atan2((p1[0] - p0[0]), (p1[1] - p0[1])))
# Nur Winkel mit erlaubten Winkeln darstellen
if angle in allowed_values:
relevant_lines.append((angle, p0, p1, list(), list()))
relevant_lines_no_angle.append((p0, p1))
ax[1].plot((p0[0], p1[0]), (p0[1], p1[1]))
ax[1].text(p0[0], p0[1], "P0", fontsize=10)
ax[1].text(p1[0], p1[1], "P1", fontsize=10)
return relevant_lines, relevant_lines_no_angle
def _main(self):
if not self.state['pause']:
self._actual_main()
else:
self._hide_all_tags()
if not self.state['quit']:
wx.CallLater(config.getint('GUI_LOOP_DELAY_MS'), self._main)
else:
self.gms.close()
wx.Exit()
def __init__(self, socket=None):
wx.Frame.__init__(self, None, -1, 'TorChat', size=(250, 350))
self.conns = []
self.chat_windows = []
self.notification_window = None
self.buddy_list = tc_client.BuddyList(self.callbackMessage,
socket)
self.SetTitle('TorChat: %s' % config.getProfileLongName())
self.Bind(wx.EVT_CLOSE, self.onClose)
# setup gui elements
self.taskbar_icon = TaskbarIcon(self)
self.main_panel = wx.Panel(self)
sizer = wx.BoxSizer(wx.VERTICAL)
self.gui_bl = BuddyList(self.main_panel, self)
sizer.Add(self.gui_bl, 1, wx.EXPAND)
self.status_switch = StatusSwitch(self.main_panel, self)
sizer.Add(self.status_switch, 0, wx.EXPAND)
self.main_panel.SetSizer(sizer)
sizer.FitInside(self)
icon = wx.Icon(name=os.path.join(config.get('internal',
'icon_dir'), 'torchat.ico'),
type=wx.BITMAP_TYPE_ICO)
self.SetIcon(icon)
if not config.getint('gui', 'open_main_window_hidden'):
self.Show()
if config.get('logging', 'log_file') and config.getint('logging'
, 'log_level'):
log.debug('logging to file may leave sensitive information on disk'
)
wx.MessageBox(lang.D_LOG_WARNING_MESSAGE
% config.log_writer.file_name,
lang.D_LOG_WARNING_TITLE, wx.ICON_WARNING)
def __init__(self, socket=None):
wx.Frame.__init__(self, None, -1, 'TorChat', size=(250, 350))
self.conns = []
self.chat_windows = []
self.notification_window = None
self.buddy_list = tc_client.BuddyList(self.callbackMessage, socket)
self.SetTitle('TorChat: %s' % config.getProfileLongName())
self.Bind(wx.EVT_CLOSE, self.onClose)
# setup gui elements
self.taskbar_icon = TaskbarIcon(self)
self.main_panel = wx.Panel(self)
sizer = wx.BoxSizer(wx.VERTICAL)
self.gui_bl = BuddyList(self.main_panel, self)
sizer.Add(self.gui_bl, 1, wx.EXPAND)
self.status_switch = StatusSwitch(self.main_panel, self)
sizer.Add(self.status_switch, 0, wx.EXPAND)
self.main_panel.SetSizer(sizer)
sizer.FitInside(self)
icon = wx.Icon(name=os.path.join(config.get('internal', 'icon_dir'),
'torchat.ico'),
type=wx.BITMAP_TYPE_ICO)
self.SetIcon(icon)
if not config.getint('gui', 'open_main_window_hidden'):
self.Show()
if config.get('logging', 'log_file') and config.getint(
'logging', 'log_level'):
log.debug(
'logging to file may leave sensitive information on disk')
wx.MessageBox(
lang.D_LOG_WARNING_MESSAGE % config.log_writer.file_name,
lang.D_LOG_WARNING_TITLE, wx.ICON_WARNING)
def notify(self, name, message):
# needs unicode
if not self.IsActive():
if config.getint('gui', 'notification_flash_window'):
self.RequestUserAttention(wx.USER_ATTENTION_INFO)
self.unread += 1
self.updateTitle()
if config.getint('gui', 'notification_popup'):
nt = textwrap.fill('%s:\n%s' % (name, message), 40)
try:
NotificationWindow(self.mw, nt)
except:
# Some platforms (Mac) dont have wx.PopupWindow
# FIXME: need alternative solution
pass
if not self.IsShown():
self.mw.taskbar_icon.blink()
def _extract_params():
"""
Check if the agent parameter is valid, if the parameter is valid,
then return parameters dict, otherwise exit process.
:return: agent parameters dict.
"""
params = {}
host = config.get('server', 'host')
listen_port = config.get('server', 'listen_port')
params['host'] = host
params['listen_port'] = listen_port
default_params = {
'sink_timer_interval': '10S',
'source_timer_interval': '10S',
'channel_capacity': 1000
}
for parameter, default in default_params.items():
try:
if parameter == 'channel_capacity':
agent_parameter_value = config.getint('agent', parameter)
params[parameter] = agent_parameter_value
else:
agent_parameter_value = config.get('agent', parameter)
params[parameter] = TimeString(
agent_parameter_value).to_second()
except Exception as e:
agent_logger.error(
"An error ({error}) occurs when acquiring {parameter},"
" using default value: {default_value}.".format(
parameter=parameter, error=e, default_value=default))
params[parameter] = default_params[parameter]
params['db_host'] = config.get('agent', 'db_host')
params['db_port'] = config.get('agent', 'db_port')
params['db_type'] = config.get('agent', 'db_type')
# Https configures.
if config.has_option('security', 'tls') and config.getboolean(
'security', 'tls'):
params['agent_cert'] = os.path.realpath(
config.get('security', 'agent_cert'))
params['agent_key'] = os.path.realpath(
config.get('security', 'agent_key'))
params['ca'] = os.path.realpath(config.get('security', 'ca'))
pwd_file = os.path.join(global_vars.CURRENT_DIRNAME, 'certificate/pwf')
with open(pwd_file, mode='r') as f:
params['cert_pwd'] = f.read().strip()
return params
def startServer():
log.log(log.DEBUG, 'Starting listening server')
if config.get('general', 'socktype') == 'inet':
domain = socket.AF_INET
bindaddr = (config.get('general', 'bindaddr'), config.getint('general', 'bindport'))
else:
domain = socket.AF_UNIX
bindaddr = config.get('general', 'bindaddr')
sd = socket.socket(domain, socket.SOCK_STREAM)
sd.bind(bindaddr)
sd.listen(20)
sd.settimeout(float(config.get('general', 'accepttimeout')))
return sd
def notify(self, name, message):
# needs unicode
if not self.IsActive():
if config.getint('gui', 'notification_flash_window'):
self.RequestUserAttention(wx.USER_ATTENTION_INFO)
self.unread += 1
self.updateTitle()
if config.getint('gui', 'notification_popup'):
nt = textwrap.fill('%s:\n%s' % (name, message), 40)
try:
NotificationWindow(self.mw, nt)
except:
# Some platforms (Mac) dont have wx.PopupWindow
# FIXME: need alternative solution
pass
if not self.IsShown():
self.mw.taskbar_icon.blink()
def handle_sighup(self, signum, frame):
self.log.info('Reloading config')
self.consumers = []
self.dataset = {}
self.visualizer.dataset = []
self.visualizer.plugins = []
config = ConfigParser()
config.read(self.filename)
self.parse_config(config)
self.load_dataset()
self.visualizer.dataset = self.dataset # fulhack
self.visualizer.rows = config.getint('general', 'rows', Main.rows)
self.visualizer.init_all_plugins()
self.visualizer.resize()
self.visualizer.write_message('Reloaded config')
def __init__(self, pygame_events):
Publisher.__init__(self)
pygame_events.subscribe(self.process_pygame)
self.state = {
'up': False,
'down': False,
'left': False,
'right': False,
'action1': False,
'action2': False,
}
self.keys = {}
for key in ('up', 'down', 'left', 'right', 'action1', 'action2'):
self.keys[config.getint('Keys', key)] = key
debug('key mapping = %s', self.keys)
def __init__(self, pygame_events):
Publisher.__init__(self)
pygame_events.subscribe(self.process_pygame)
self.state = {
'up': False,
'down': False,
'left': False,
'right': False,
'action1': False,
'action2': False,
}
self.keys = {}
for key in ('up','down','left','right','action1','action2'):
self.keys[config.getint('Keys', key)] = key
debug('key mapping = %s', self.keys)
async def main(self):
while not self.is_ready():
await asyncio.sleep(0.5)
while True:
if self.state['quit']:
await self.close()
if not self.state['pause']:
self.state['names'] = self._voice_channel_member_names()
self.state['speaker_names'] = active_speaker_names(
self._voice_channel_member_names())
await asyncio.sleep(
config.getint('DISCORD_LOOP_DELAY_MS') / 1000.0)
def emailNotification(subscriber, parsed):
log.log(log.DEBUG, 'Plain email: ' + repr(subscriber))
try:
msg = message.renderMessage('email.txt', parsed)
#msg = MIMEText(msg)
#msg = msg.as_string()
eml = 'To: ' + subscriber + '\r\n'
eml += 'From: IETF Notifier <' + config.get('notify-email', 'smtpfrom') + '>\r\n'
#eml += 'Subject: ' + parsed['doc-tag'][0] + ' has been updated\r\n'
eml += 'Precedence: list\r\n'
eml += 'Auto-submitted: auto-generated\r\n'
eml += msg
smtp = smtplib.SMTP(config.get('notify-email', 'smtphost'), config.getint('notify-email', 'smtpport'))
smtp.sendmail(config.get('notify-email', 'smtpfrom'), subscriber, eml)
smtp.quit()
except smtplib.SMTPDataError:
log.log(log.ERROR, 'Error sending email notification: ' + subscriber)
def main_loop():
pool_size = config.getint('gevent', 'worker.pool.size')
pool = gevent.pool.Pool(pool_size)
logger.info('Started gevent pool with size %d', pool_size)
consumer = kafkareader.create_consumer(config)
while True:
try:
raw_event = kafkareader.read_message(consumer)
logger.debug('READ MESSAGE %s', raw_event)
event = MessageItem(**json.loads(raw_event))
if event.get_message_type() in known_messages\
or event.get_command() in known_commands:
pool.spawn(topology_event_handler, event)
else:
logger.debug('Received unknown type or command %s', raw_event)
except Exception as e:
logger.exception(e.message)
def send(self):
addresses = []
for header_name in ("To", "Cc", "Bcc"):
for header in self.get_all(header_name, []):
addresses.append(email.utils.parseaddr(decode(header))[1])
del self["Bcc"]
name, address = email.utils.parseaddr(u"Guillaume Ayoub <*****@*****.**>".encode("utf-8"))
if name:
name = email.header.Header(name, "utf-8").encode()
self["From"] = email.utils.formataddr((name, address))
else:
self["From"] = address
self["Date"] = email.utils.formatdate(time.time(), True)
self["X-Mailer"] = "Mailanie %s" % config.get("mailanie", "version")
server = config.get("smtp", "server")
port = config.getint("smtp", "port")
if config.getboolean("smtp", "ssl"):
client = smtp.SMTP_SSL(server, port)
else:
client = smtp.SMTP(server, port)
login = config.get("smtp", "login")
if login:
password = config.get("smtp", "password")
client.login(login, password)
name = config.get("smtp", "name")
address = config.get("smtp", "address")
if name:
sender = "%s <%s>" % (name, address)
else:
sender = address
client.sendmail(sender, addresses, self.as_string())
sent_folder = mailanie.mailbox.get_folder(config.get("mailbox", "sent"))
sent_folder.add(self)
def main_loop():
pool_size = config.getint('gevent', 'worker.pool.size')
logger.info('\n\nWHAT WHAT v002\n\n')
logger.info('Start gevent pool with size {}.'.format(pool_size))
pool = gevent.pool.Pool(pool_size)
consumer = kafkareader.create_consumer(config)
while True:
try:
raw_event = kafkareader.read_message(consumer)
logger.debug('READ MESSAGE %s', raw_event)
event = MessageItem(**json.loads(raw_event))
if event.get_message_type() in known_messages\
or event.get_command() in known_commands:
logger.debug('Processing message payload', event.payload)
pool.spawn(topology_event_handler, event)
except Exception as e:
logger.exception(e.message)
def _ocr_name_to_slot_matching(self):
def best_match(name, names, threshold):
score, match = max(
[(match_score(x, name), x)
for x in names if match_score(x, name) >= threshold],
default=(None, None))
if score is None:
return None
else:
return match
def match_score(a, b):
# length of longest common prefix
i = 0
while i < min(len(a), len(b)) and a[i] == b[i]:
i += 1
return i
# reset the mapping
self._ocrd_name_to_slot_idx = dict()
# generate new mapping
print('starting generating mapping of names to slots...')
slot_names = [name.lower() for name in self.gms.ocr_slot_names()]
print('slot_names:', slot_names)
for name in self._name_tags_by_name.keys():
match = best_match(
name.lower(),
slot_names,
threshold=config.getint('LENGTH_NAME_MATCHING_PREFIX'))
if not match:
continue
self._ocrd_name_to_slot_idx[name] = slot_names.index(match)
self._just_ocrd_name_to_slot = True
def main():
file = open("torchatlog.txt", "w")
file.write('Ready')
file.close()
file = open("pid-torchat.txt", "w")
file.write('python|' + str(os.getpid()))
file.close()
#test for availability of our listening port
interface = config.get("client", "listen_interface")
port = config.getint("client", "listen_port")
print "(1) opening TorChat listener on %s:%s" % (interface, port)
listen_socket = tc_client.tryBindPort(interface, port)
if not listen_socket:
print "(1) %s:%s is already in use" % (interface, port)
return
else:
print "(1) TorChat is listening on %s:%s" % (interface, port)
#now continue with normal program startup
print "(1) start initializing main window"
tc_gui.MainWindow(listen_socket)
def run():
utils.init_logging()
logger.info('Monobox fetcher starting up')
config.init()
database.init(config.get('common', 'database_uri'))
max_age = config.get('fetcher', 'max_age')
if max_age:
timedelta = utils.str_to_timedelta(max_age)
if timedelta is None:
logger.error('Cannot convert configuration parameter '
'max_age (%s) to timedelta' % max_age)
sys.exit(1)
else:
timedelta = None
urls = config.get('fetcher', 'sc_urls').split(' ')
listeners_min = config.getint('fetcher', 'listeners_min')
for url in urls:
merge_sc_stations(url, listeners_min)
if timedelta is not None:
purge_old_stations(timedelta)
def __init__(self):
self._iremocon_ip = config.get('iremocon', 'ip')
self._iremocon_port = config.getint('iremocon', 'port')
self._sock = self.__get_iremocon_connection()
self._pattern = re.compile('\w+;ok;(.+)\r\n')
import sys
import discord
import config
from bot import Revive
from logger import Logger
prefix = config.get('Bot', 'Prefix')
token = config.get('Bot', 'Token')
owner_id = config.getint('Bot', 'OwnerID')
allowed_mentions = discord.AllowedMentions.none()
intents = discord.Intents.none()
intents.messages = True
intents.guild_reactions = True
intents.guilds = True
bot = Revive(prefix,
allowed_mentions=allowed_mentions,
intents=intents,
owner_id=owner_id)
bot.logger = Logger()
bot.logger.start()
bot.load_extension('cogs.help')
bot.load_extension('cogs.library')
bot.load_extension('cogs.mod')
bot.load_extension('cogs.stats')
def run():
init()
app.run(host=config.get('server', 'listen_address'),
port=config.getint('server', 'listen_port'))
def callbackMessage(self, callback_type, callback_data):
# we must always use wx.CallAfter() to interact with
# the GUI-Thread because this method will be called
# in the context of one of the connection threads
if callback_type == tc_client.CB_TYPE_CHAT:
(buddy, message) = callback_data
for window in self.chat_windows:
if window.buddy == buddy:
wx.CallAfter(window.process, message)
return
# no window found, so we create a new one
hidden = config.getint('gui', 'open_chat_window_hidden')
wx.CallAfter(ChatWindow, self, buddy, message, hidden)
# we let this thread block until the window
# shows up in our chat window list
found = False
while not found:
time.sleep(1)
for window in self.chat_windows:
if window.buddy == buddy:
found = True
break
if callback_type == tc_client.CB_TYPE_OFFLINE_SENT:
buddy = callback_data
for window in self.chat_windows:
if window.buddy == buddy:
wx.CallAfter(window.notifyOfflineSent)
return
hidden = config.getint('gui', 'open_chat_window_hidden')
wx.CallAfter(
ChatWindow,
self,
buddy,
'',
hidden,
notify_offline_sent=True,
)
if callback_type == tc_client.CB_TYPE_FILE:
# this happens when an incoming file transfer was initialized
# we must now create a FileTransferWindow and return its
# event handler method to the caller
receiver = callback_data
buddy = receiver.buddy
file_name = receiver.file_name
# we cannot get return values from wx.CallAfter() calls
# so we have to CallAfter() and then just wait for
# the TransferWindow to appear.
wx.CallAfter(FileTransferWindow, self, buddy, file_name,
receiver)
__author__ = '*****@*****.**'
import dbwrapper
import flask
import httpclient
import config
import os
# DB
db = dbwrapper.DBWrapper(host=config.get(u'db', u'host'),
port=config.getint(u'db', u'port', 3306),
user=config.get(u'db', u'user'),
passwd=config.get(u'db', u'passwd', u''),
db=config.get(u'db', u'db'))
# Http client
wutong_client = httpclient.HttpClient(
config.get(u'wutong', u'server', u'http://apitest.borqs.com'))
# WebApp
app = flask.Flask(u'IABMarket', static_folder=u'market')
upload_folder = os.path.join(os.path.dirname(__file__), u'upload')
if not os.path.exists(upload_folder):
os.mkdir(upload_folder)
app.config[u'UPLOAD_FOLDER'] = upload_folder
app.secret_key = 'xHVGDBB1RDDWYlp5zApBcQ==' # do not change
app.jinja_options = {'extensions': ['jinja2.ext.do']}
@app.route(u'/upload/<path:filename>')
def base_static(filename):
def readConfig(self, section, option):
return config.getint(section, option)
if user.username not in self.low_margin_users:
self.low_margin_users[user.username] = datetime.datetime.utcnow()
self.email_user(user, self.cash_positions[user.username], low_margin, high_margin, severe=False)
result = "WARNING"
else:
if user.username in self.low_margin_users:
del self.low_margin_users[user.username] # resolved
if user.username in self.bad_margin_users:
del self.bad_margin_users[user.username] # resolved
result = "OK"
log.msg("%s: %s / %d %d %d" % (result, user.username, low_margin, high_margin,
self.cash_positions[user.username]))
if __name__ == "__main__":
log.startLogging(sys.stdout)
session = database.make_session()
safe_price_subscriber = connect_subscriber(config.get("safe_price_forwarder", "zmq_backend_address"))
safe_price_subscriber.subscribe('')
sendmail = Sendmail(config.get("riskmanager", "from_email"))
accountant = AccountantProxy("dealer",
config.get("accountant", "riskmanager_export"),
config.getint("accountant", "riskmanager_export_base_port"))
riskmanager = RiskManager(session, sendmail, safe_price_subscriber, accountant)
reactor.run()
def readConfig(self, section, option):
return config.getint(section, option)
__author__ = '*****@*****.**'
import dbwrapper
import flask
import httpclient
import config
import os
# DB
db = dbwrapper.DBWrapper(
host=config.get(u'db', u'host'),
port=config.getint(u'db', u'port', 3306),
user=config.get(u'db', u'user'),
passwd=config.get(u'db', u'passwd', u''),
db=config.get(u'db', u'db'))
# Http client
wutong_client = httpclient.HttpClient(config.get(u'wutong', u'server', u'http://apitest.borqs.com'))
# WebApp
app = flask.Flask(u'IABMarket', static_folder=u'market')
upload_folder = os.path.join(os.path.dirname(__file__), u'upload')
if not os.path.exists(upload_folder):
os.mkdir(upload_folder)
app.config[u'UPLOAD_FOLDER'] = upload_folder
app.secret_key = 'xHVGDBB1RDDWYlp5zApBcQ==' # do not change
app.jinja_options = {'extensions': ['jinja2.ext.do']}
@app.route(u'/upload/<path:filename>')
def base_static(filename):
def init():
global _defaultThreadPool
if _defaultThreadPool:
return
threshold = config.getint('update_threshold', 1)
_defaultThreadPool = ThreadPool(name='UpdateRSS', threshold=threshold)
iremocon_command = extract_notify_cin_con(str_payload)
print(iremocon_command)
if iremocon_command is None:
return
irgw.send_command(iremocon_command)
def __on_disconnect(client, irgw, rc):
irgw.close()
if __name__ == '__main__':
broker_ip = config.get('mqtt_broker', 'ip')
broker_port = config.getint('mqtt_broker', 'port')
sub_topic = config.get('mqtt_client', 'sub_topic')
irgw = iremocon_util.IRemoconGW()
try:
client = mqtt.Client(protocol=mqtt.MQTTv311, userdata=irgw)
client.on_connect = __on_connect
client.on_message = __on_message
client.on_disconnect = __on_disconnect
client.connect(broker_ip, port=broker_port, keepalive=60)
print('Connected sucessfully to MQTT Broker.')
client.loop_forever()
datefmt=log_datefmt)
if __name__ == '__main__':
uhc_local_dir = os.path.expanduser("~/.uhc")
try:
os.mkdir(uhc_local_dir)
except FileExistsError:
pass
config = config.Config(uhc_local_dir)
log_file = uhc_local_dir + "/uhc.log"
log_level = config.getint("logging", "level")
initLog(log_file, log_level)
logging.info("--------- Init ---------")
c = Controller(config)
firstrun = True
while True :
try:
if not firstrun:
time.sleep(30)
firstrun = False
c.run()
except KeyboardInterrupt:
logging.info("Exiting after KeyboardInterrupt")
sys.exit()
def __init__(self, cashier):
self.cashier = cashier
ComponentExport.__init__(self, cashier)
@export
@session_aware
@schema("rpc/cashier.json#request_withdrawal")
def request_withdrawal(self, username, ticker, address, amount):
return self.cashier.request_withdrawal(username, ticker, address, amount)
if __name__ == '__main__':
log.startLogging(sys.stdout)
accountant = AccountantProxy("dealer",
config.get("accountant", "cashier_export"),
config.getint("accountant", "cashier_export_base_port"))
session = db.make_session()
bitcoin_conf = config.get("cashier", "bitcoin_conf")
log.msg('connecting to bitcoin client')
bitcoinrpc = {'BTC': BitcoinRpc(bitcoin_conf, 1)}
compropago = Compropago(config.get("cashier", "compropago_key"))
cold_wallet_period = config.getint("cashier", "cold_wallet_period")
sendmail=Sendmail(config.get("administrator", "email"))
minimum_confirmations = config.getint("cashier", "minimum_confirmations")
alerts_proxy = AlertsProxy(config.get("alerts", "export"))
bitgo_config = {'use_production': not config.getboolean("cashier", "testnet"),
'client_id': config.get("bitgo", "client_id"),
'client_secret': config.get("bitgo", "client_secret")}
#!/usr/bin/python
__author__ = '*****@*****.**'
import config
import gv
__import__('purchaser_controllers')
__import__('account_controllers')
__import__('publisher_controllers')
wsgi_server = config.get(u'web', u'wsgi_server', u'')
if wsgi_server.lower() == u'tornado':
print u'Tornado start'
from tornado.wsgi import WSGIContainer
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
server = HTTPServer(WSGIContainer(gv.app))
server.listen(config.getint(u'web', u'port'), address=config.get(u'web', u'host', u''))
IOLoop.instance().start()
else:
print u'Flask start'
gv.app.run(host=config.get(u'web', u'host', u'0.0.0.0'),
port=config.getint(u'web', u'port', 6789),
debug=config.getboolean(u'misc', u'debug', False))
