def make_rss(self, info_blocks):
"""
Produces RSS from
- already saved informations
- new data
:param info_blocks: fresh data
:return: -
"""
if self.rss_filename:
self.logger.debug(f"Loading RSS data feed : {self.rss_filename}")
rpps_updates = helpers.load_json(self.rss_filename)
if "updates" not in rpps_updates:
rpps_updates = {"updates": []}
self.logger.info(rpps_updates)
inf = info.Info(self.properties)
feed_info = list(map(lambda i: inf.feed_info(i), info_blocks))
d = inf.to_rss(feed_info, self.rpps_data.data_date,
self.data_files)
self.logger.debug(f"Insert (top) history : {d}")
rpps_updates["updates"].insert(0, d)
if self.rss_history:
rpps_updates["updates"] = rpps_updates["updates"][:self.
rss_history]
helpers.save_json(self.rss_filename, rpps_updates)
# produce RSS/atom file
result = self.feed.generate(rpps_updates["updates"])
self.feed.save(result)
self.feed.rss2()
def get_hostlist(self, server, port, user, password, opts):
try:
opts.append(("-o", "return"))
nodes = listservers.ListServers().runCmd('host-list', server, port,
user, password, False,
opts)
for node in nodes:
(node_server, node_port) = util.hostport(node['hostname'])
node_stats = {
"host": node_server,
"port": node_port,
"status": node['status'],
"master": server
}
stats_buffer.nodes[node['hostname']] = node_stats
if node['status'] == 'healthy':
node_info = info.Info().runCmd('get-server-info',
node_server, node_port,
user, password, False, opts)
self.retrieve_node_stats(node_info, node_stats)
else:
self.log.error("Unhealthy node: %s:%s" %
(node_server, node['status']))
return nodes
except Exception, err:
traceback.print_exc()
sys.exit(1)
def main():
# Parse user arguments
parser = argparse.ArgumentParser("Syncthing client")
parser.add_argument("-d", "--directory", dest="sync_directory",\
type=str, help="Main sync directory", required=True)
parser.add_argument("-c", "--cert",dest="cert", type=str,\
help="Certificate file", required=True)
parser.add_argument("-k", "--key", dest="key", type=str,\
help="Private key file", required=True)
parser.add_argument("-i", "--ip", dest="ip", type=str,\
help="Server IP", required=True)
parser.add_argument("-p", "--port", dest="port", type=int,\
help="Server port", required=True)
parser.add_argument("-v", "--verbose", dest="verbose",\
help="Increase output verbosity", action="store_true", required=False)
args = parser.parse_args()
# Init client info
user_info = info.Info(args.sync_directory, args.cert, args.key, args.ip, args.port, args.verbose)
user_info.gen_device_id()
# Init Syncthing
process = syncthing.Syncthing(user_info)
process.start()
process.join()
def parse_result(self):
given_url = self.find('given_url')
given_url = given_url.get_attribute('href')
url = self.find('url')
url = url.get_attribute('href')
cookies = self.find('cookies')
cookies = cookies.text
cookies = int(cookies)
return info.Info(given_url, url, cookies)
def __init__(self, raw=False, callStats=False, reactor=None):
"""C{CallRunner(raw=False, callStats=False, reactor=None)}"""
self.raw = raw
self.info = info.Info()
self.callStats = callStats
if callStats:
self.callTimes = []
self.reactor = reactor
if reactor and not raw:
raise ValueError("Only raw mode supported with a process reactor!")
def build(self):
self.root = ScreenManager()
self.root.add_widget(info.Info(self.root))
self.game_inspector = session.GameInspector()
self.session_settings = config_session.SessionSettings(
self.root, self.game_inspector)
self.root.add_widget(self.session_settings)
self.root.add_widget(self.game_inspector)
self.root.current = 'Info'
return self.root
def sign_in(self, name, phone):
"""로그인"""
if name == 'teacher' and phone == '0000':
return 'teacher'
conn = db.connect("hr", "hr", "localhost:1521/xe",
encoding='utf-8') # db 연결
cursor = conn.cursor()
sql = 'select * from students where name=:1 and phone=:2'
d = (name, phone)
cursor.execute(sql, d) # sql문 실행
row = cursor.fetchone() # 검색 결과 가져오기
conn.close() # 연결 끊기
if row is None:
# 검색 결과 없으면 False
return False
student = info.Info(row[0], row[1], row[2],
row[3]) # 받아온 정보로 Info 객체 생성
student.print_info()
return student
def __init__(self, working_dir):
Gtk.Window.__init__(self)
self.connect('destroy', self.destroy_cb)
self.set_position(Gtk.WindowPosition.CENTER_ALWAYS)
self.set_resizable(False)
self.set_title(working_dir)
os.chdir(working_dir)
self.stage = next(discover_stages(), None)
if self.stage is None:
sys.exit("unable to locate THORLABS stage")
self.focus_window = None
self.config_window = None
self.capture_selection = None
self.capture_position = None
self.capture_location = None
# used to normalise start and end times
self.capture_start_pos = None
self.capture_start_time = None
# queue for image saving to not compromise fps
self.capture_image_queue = queue.Queue()
self.vbox = Gtk.VBox(False, 0)
self.add(self.vbox)
self.vbox.show()
fixed = Gtk.Fixed()
self.vbox.pack_start(fixed, False, True, 0)
fixed.show()
self.camera = camera.Camera()
self.preview = preview.Preview(self.camera)
fixed.put(self.preview, 0, 0)
self.preview.show()
eb = Gtk.EventBox()
fixed.put(eb, 0, 0)
eb.show()
self.progress = progress.Progress()
self.progress.set_size_request(preview_width, -1)
eb.add(self.progress)
eb = Gtk.EventBox()
fixed.put(eb, 0, 0)
eb.show()
self.info = info.Info()
self.info.set_size_request(preview_width, -1)
eb.add(self.info)
self.toolbar = Gtk.HBox(False, 5)
self.toolbar.set_border_width(3)
self.vbox.pack_end(self.toolbar, False, False, 0)
self.toolbar.show()
button = Gtk.Button()
quit_image = Gtk.Image.new_from_stock(Gtk.STOCK_QUIT,
Gtk.IconSize.SMALL_TOOLBAR)
quit_image.show()
button.set_tooltip_text("Quit RTIAcquire")
button.connect('clicked', self.destroy_cb, None)
button.add(quit_image)
self.toolbar.pack_end(button, False, False, 0)
button.show()
button = Gtk.Button()
menu_image = Gtk.Image.new_from_stock(Gtk.STOCK_PREFERENCES,
Gtk.IconSize.SMALL_TOOLBAR)
menu_image.show()
button.set_tooltip_text("Camera settings")
button.connect('clicked', self.config_cb, None)
button.add(menu_image)
self.toolbar.pack_end(button, False, False, 0)
button.show()
label = Gtk.Label()
self.toolbar.pack_end(label, False, False, 0)
self.preview.score_label = label
label.show()
spinner = Gtk.SpinButton.new_with_range(1, 4, 0.1)
spinner.set_tooltip_text("Maximum velocity of turntable")
spinner.set_value(self.stage.max_velocity)
self.toolbar.pack_start(spinner, False, False, 0)
self.max_velocity = spinner
spinner.show()
entry = Gtk.Entry.new()
entry.set_tooltip_text("Seal name")
entry.set_placeholder_text("Name of Seal")
self.toolbar.pack_start(entry, False, False, 0)
self.seal_name = entry
entry.show()
radio = Gtk.RadioButton.new_with_label(None, "Direct LED")
self.direct_led = radio
self.toolbar.pack_start(radio, False, False, 0)
radio.show()
radio = Gtk.RadioButton.new_with_label_from_widget(
radio, "Structured Light")
self.toolbar.pack_start(radio, False, False, 0)
radio.show()
button = Gtk.Button("Start Capture")
button.set_tooltip_text("Start seal capture")
button.connect('clicked', self.capture_cb, None)
self.toolbar.pack_start(button, False, False, 0)
self.capture = button
button.show()
self.info.msg('Something Something Something', 'v0.1, July 2017')
self.progress.progress(0.2)
self.preview.set_live(True)
self.show()
async def on_ready():
await bot.change_presence(status=discord.Status.online, activity=discord.Game('Made by Shep and Peter!'))
print(f'Logged in as: {bot.user.name}')
print(f'With ID: {bot.user.id}')
@bot.event
async def on_command_completion(ctx):
global command_impact
command_impact += 1
def get_impact():
global command_impact
return command_impact
bot.add_cog(settings.Settings(bot))
bot.add_cog(calculate.Calculate(bot))
bot.add_cog(results.Results(bot))
bot.add_cog(CommandErrorHandler.CommandErrorHandler(bot))
bot.add_cog(info.Info(bot))
bot.add_cog(DataSender.DataSender(bot, guild_id))
bot.add_cog(DataWriter.DataWriter(bot))
bot.add_cog(MatchMaker.MatchMaker(bot))
bot.add_cog(help_functions.Impact(bot))
if "BOT_TOKEN" in os.environ.keys():
print("Starting bot...")
bot.run(os.environ['BOT_TOKEN'])
else:
print(os.environ.keys())
with open('work_bot_token.txt', 'r') as f:
bot.run(f.read().strip())
import time import info import wx info = info.Info() def GetInfo(): global info return info def SetInfo(data): global info info = data def wait(ms): mytime = time.clock() while time.clock() < mytime + ms*0.0001: print time.clock() print mytime + ms return
import falcon
import info
import answer
import mytime
from wsgiref import simple_server
api = falcon.API()
api.add_route('/info', info.Info())
api.add_route('/answer', answer.Answer())
api.add_route('/time', mytime.Mytime())
# Useful for debugging problems in your API; works with pdb.set_trace()
if __name__ == '__main__':
httpd = simple_server.make_server('127.0.0.1', 8000, api)
httpd.serve_forever()
def on_itemHelp_activate(self, widget):
i_app = info.Info()
i_app.main()
def __init__(self):
gtk.Window.__init__(self)
self.connect('destroy', self.destroy_cb)
self.config_window = None
self.live_hide_timeout = 0
self.light_hop_timeout = 0
self.busy = False
self.leds = ledmap.Ledmap(os.path.join(source_dir, 'data',
'led-maps.txt'))
logging.debug('loaded %d maps', len(self.leds.get_names()))
for name in self.leds.get_names():
bytes = self.leds.get_bytes(name)
logging.debug('%s: %d lights', name, len(bytes))
# where project directories get written, see RTI cap above
self.outdir = options.outdir
self.lights = lights.Lights()
# try to reset the lights ... if this fails, disable dome controls
try:
self.dome_controls = True
name = self.leds.get_names()[0]
self.lights.set_triple(self.leds.get_bytes(name)[0])
except lights.Error as e:
logging.debug('no lights found, disabling dome controls')
self.dome_controls = False
self.vbox = gtk.VBox(False, 0)
self.add(self.vbox)
self.vbox.show()
fixed = gtk.Fixed()
self.vbox.pack_start(fixed, False)
fixed.show()
self.camera = camera.Camera()
self.preview = preview.Preview(self.camera)
fixed.put(self.preview, 0, 0)
self.preview.show()
self.preview.connect('motion_notify_event', self.preview_motion_cb)
if options.verbose:
try:
config = camera.Config(self.camera)
config.prettyprint(sys.stdout, config.get_root_widget())
except:
logging.debug("No Camera detected: unable to print config")
eb = gtk.EventBox()
fixed.put(eb, 0, 0)
eb.show()
self.progress = progress.Progress()
self.progress.set_size_request(preview_width, -1)
eb.add(self.progress)
eb = gtk.EventBox()
fixed.put(eb, 0, 0)
eb.show()
self.info = info.Info()
self.info.set_size_request(preview_width, -1)
eb.add(self.info)
eb = gtk.EventBox()
fixed.put(eb, 20, 380)
eb.show()
self.play_image = gtk.image_new_from_stock(gtk.STOCK_MEDIA_PLAY,
gtk.ICON_SIZE_SMALL_TOOLBAR)
self.pause_image = gtk.image_new_from_stock(gtk.STOCK_MEDIA_PAUSE,
gtk.ICON_SIZE_SMALL_TOOLBAR)
self.live = gtk.Button()
self.live.set_image(self.play_image)
self.live.set_tooltip_text("Start/stop live preview")
self.live.connect('clicked', self.live_cb, None)
eb.add(self.live)
self.live.show()
self.toolbar = gtk.HBox(False, 5)
self.toolbar.set_border_width(3)
self.vbox.pack_end(self.toolbar)
self.toolbar.show()
button = gtk.Button()
quit_image = gtk.image_new_from_stock(gtk.STOCK_QUIT,
gtk.ICON_SIZE_SMALL_TOOLBAR)
quit_image.show()
button.set_tooltip_text("Quit RTIAcquire")
button.connect('clicked', self.destroy_cb, None)
button.add(quit_image)
self.toolbar.pack_end(button, False, False)
button.show()
if self.dome_controls:
self.dome_picker = gtk.combo_box_new_text()
for name in self.leds.get_names():
self.dome_picker.append_text(name)
self.dome_picker.set_active(0)
self.dome_picker.set_tooltip_text("Select lighting system")
self.dome_picker.connect('changed', self.dome_picker_cb, None)
self.toolbar.pack_start(self.dome_picker, False, False)
self.dome_picker.show()
self.light_picker = gtk.SpinButton(climb_rate = 1)
self.light_picker.set_numeric(True)
self.light_picker.set_wrap(True)
self.light_picker.set_increments(1, 1)
self.light_picker.set_tooltip_text("Pick light")
self.light_picker_refresh()
self.light_picker.connect('value_changed',
self.light_picker_cb, None)
self.toolbar.pack_start(self.light_picker, False, False)
self.light_picker.show()
button = gtk.Button()
menu_image = gtk.image_new_from_stock(gtk.STOCK_PREFERENCES,
gtk.ICON_SIZE_SMALL_TOOLBAR)
menu_image.show()
button.set_tooltip_text("Camera settings")
button.connect('clicked', self.config_cb, None)
button.add(menu_image)
self.toolbar.pack_start(button, False, False)
button.show()
button = gtk.Button('Focus')
button.set_tooltip_text("Focus camera automatically")
button.connect('clicked', self.focus_cb, None)
self.toolbar.pack_start(button, False, False)
button.show()
photo_image = gtk.image_new_from_file(
os.path.join(source_dir, 'data', 'camera_24.png'))
photo = gtk.Button()
photo.set_image(photo_image)
photo.set_tooltip_text("Take single photo")
photo.connect('clicked', self.photo_cb, None)
self.toolbar.pack_start(photo, False, False)
photo.show()
if self.dome_controls:
photo = gtk.Button('RTI Preview')
photo.set_tooltip_text("Take preview RTI image")
photo.connect('clicked', self.rti_preview_cb, None)
self.toolbar.pack_start(photo, False, False)
photo.show()
photo = gtk.Button('RTI Capture ...')
photo.set_tooltip_text("Start full RTI acquisition")
photo.connect('clicked', self.rti_capture_cb, None)
self.toolbar.pack_start(photo, False, False)
photo.show()
self.info.msg('Welcome to RTI Acquire', 'v1.3, March 2014')
self.show()
def info(self, schema, view):
return info.Info(self, schema, view)
def main():
screendimensions = (1000, 600)
griddimensions = (720, 450)
os.environ['SDL_VIDEO_WINDOW_POS'] = "%d,%d" % (50, 50)
pygame.init()
screen = pygame.display.set_mode(screendimensions)
font = pygame.font.SysFont("quartzms", 50)
loading = pygame.sprite.Sprite()
loading.image = font.render('- LOADING-', True, white)
loading.rect = loading.image.get_rect()
loading.rect.centerx = screendimensions[0] / 2
loading.rect.centery = screendimensions[1] / 2
screen.blit(loading.image, loading.rect)
pygame.display.flip()
clock = pygame.time.Clock()
mousevisible = False
pygame.mouse.set_visible(mousevisible)
color1 = red
color2 = white
manager = blocks.BlockManager(color1, color2, 125, 1.5,
(screendimensions[0] - griddimensions[0]) /
2,
screendimensions[1] - griddimensions[1] - 20)
inf = info.Info(screendimensions[0], screendimensions[1])
menu = Menu(screendimensions)
songs = glob('*.ogg')
shuffle(songs)
print(songs)
if songs:
pygame.mixer.music.load(songs[0])
pygame.mixer.music.play()
currentsong = 0
songlengths = []
for song in songs:
songlengths.append(pygame.mixer.Sound(song).get_length())
while 1:
time = clock.tick(60) / 1000
for event in pygame.event.get():
if event.type == QUIT:
pygame.mixer.music.stop()
return
elif event.type == MOUSEBUTTONDOWN:
if menu.enabled:
if menu.option == -2:
pygame.mixer.music.stop()
return
elif menu.option == 0:
mousevisible = False
pygame.mouse.set_visible(mousevisible)
menu.HideMenu()
elif menu.option == 1:
manager.NewGame()
inf.reset()
elif event.type == KEYDOWN:
if event.key == K_ESCAPE:
mousevisible = not mousevisible
pygame.mouse.set_visible(mousevisible)
menu.ToggleMenu()
# Send keyboard input to manager to be handled
if not menu.enabled and not inf.IsGameOver():
manager.KeydownHandler(event.key)
elif event.type == KEYUP and not inf.IsGameOver():
if not menu.enabled:
manager.KeyupHandler(event.key)
if songs and pygame.mixer.music.get_pos() / 1000 + 1 > songlengths[
currentsong]:
currentsong = (currentsong + 1) % len(songs)
pygame.mixer.music.load(songs[currentsong])
pygame.mixer.music.play()
if menu.enabled:
choice = menu.update(pygame.mouse.get_pos())
else:
if not inf.IsGameOver():
if manager.score == -1:
print('main gameover')
inf.GameOver()
else:
manager.update(time)
inf.update(manager.score)
screen.fill(charcoal)
manager.draw(screen)
inf.draw(screen)
menu.draw(screen)
pygame.display.flip()
