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(): 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 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()
__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))