def __init__(self):
settings = dict(
template_path = 'templates',
static_path = 'static',
static_url_path = '/static/',
xsrf_cookies = True,
debug = True,
login_url = '/login',
cookie_secret = "erfI2CItqdJG2AA1su5103panMMlr05ZmamQXSf3OPoq0Bury1YteKtHPAmA+TxWtrTnVNTrOevT==",
session_secret = "OLza01dzGmWXf0V910zynJ4IkrYtR74GWi4pXwR8ZY/DssIhIRPV7CrVY4XclVYdHoAZCCIQtQB==",
session_timeout = 60,
store_options = {
'redis_host': '192.168.47.20',
'redis_port': 6379,
'redis_pass': '',
},)
handlers = [
(r"/", MainHandler),
(r"", MainHandler),
(r"/login", LoginHandler),
(r"/logout", LogoutHandler),
]
tornado.web.Application.__init__(self, handlers, **settings)
self.session_manager = SessionManager(settings["session_secret"], settings["store_options"], settings["session_timeout"])
def __init__(self, socket_params, opts):
""" Set up a new instance """
self.version = __version__
self.opts = opts
self._setup_logging()
server_address = (opts.host, opts.port)
self.httpserver = HTTPServer(server_address, HTTPRequestHandler, self)
self._setup_openid()
self.auth_service = AuthService()
self.sess_manager = SessionManager()
self.consumer_auth_store = ConsumerAuthStore()
def file_2_db(dburi, directory):
"""
read from files and write the configuration into database.
:param dburi: database uri
:param directory: folder to read
:return: None
"""
sm = SessionManager()
sess = sm.get_session(dburi)
sm.prepare_db(dburi, [PGEMConfig, TestItem])
# file to db
file_list = []
for root, folder, files in os.walk(directory):
for f in files:
# if(f.endswith(".xml") or f.endswith(".XML")):
regex = re.compile(r"AGIGA\d{4}\-\d{3}\w{3}-\d{2}\.xml",
re.IGNORECASE)
if (regex.match(f)):
file_list.append(os.path.join(root, f))
for f in file_list:
config = load_xml(f)
logger.debug(config)
result = sess.query(PGEMConfig).filter(
PGEMConfig.partnumber == config["partnumber"],
PGEMConfig.revision == config["revision"]).first()
if result:
pgem_config = result
pgem_config.testitems = []
else:
pgem_config = PGEMConfig()
for k, v in config.items():
if k != "testitems" and k != "TESTITEMS":
setattr(pgem_config, k.lower(), v)
else:
items = v
for tk, tv in items.items():
test_item = TestItem()
setattr(test_item, "NAME".lower(), tk)
for dk, dv in tv.items():
setattr(test_item, dk.lower(), dv)
pgem_config.testitems.append(test_item)
logger.debug(pgem_config)
try:
sess.add(pgem_config)
sess.commit()
except Exception as e:
sess.rollback()
raise e
finally:
sess.close()
def connectServer(self):
cfg = self.settings.connection
constr = f'{cfg.ip}:{cfg.port}'
if cfg.use_ssl:
raise Exception('bitte Sebastian ssl einbauen')
else:
self.channel = grpc.insecure_channel(constr)
self._load_categories()
self._load_model_metadata()
self.stlloadthread = _StlLoadThread(self.channel)
self.sessionManager = SessionManager(self.channel)
self.filterManager = FilterManager(self.categories,
self.modelsMetaData)
def db_2_file(dburi, directory):
"""
read out from config database, save to single file
:param dbrui: database uri
:param directory: folder to save the xml files
:return: None
"""
sm = SessionManager()
sess = sm.get_session(dburi)
sm.prepare_db(dburi, [PGEMConfig, TestItem])
# db to file
for config in sess.query(PGEMConfig).all():
save_config(config.to_dict(), directory)
sess.close()
def load_config(dburi, partnumber, revision):
"""
:param dburi: database uri, eg. "sqlite:///config.db"
:param partnumber: partnumber of DUT, eg. "AGIGA9601-002BCA"
:param revision: revision of DUT, eg."04"
:return: PGEMConfig object
"""
sm = SessionManager()
sess = sm.get_session(dburi)
pgem_config = sess.query(PGEMConfig).filter(
PGEMConfig.partnumber == partnumber,
PGEMConfig.revision == revision,
).first()
if pgem_config is None:
raise BackendException(partnumber +
" is not found in configuration database")
logger.debug(pgem_config.to_dict())
sess.close()
return pgem_config
def message_handler(pipe, lock):
"""A Process task handler performing a loop on pipe.recv()
Pass any messages to the session.SessionManager
"""
log('-- Starting connect handler\n')
handler = SessionManager(pipe, lock)
# send back into the start method -
pipe.send(handler.init_response())
while True:
try:
msg = pipe.recv()
if msg == 'close':
log('connect.message_handler received message from session pipe')
log(message)
break
handler.kill()
handler.recv(msg)
except (EOFError, KeyboardInterrupt):
break
pipe.close()
def main():
global constants
# enable cudnn auto-tuner to find the best algorithm for the given harware
cudnn.benchmark = True
sm = SessionManager(dataset_name=args.dataset_name,
resume_id=args.session_id)
labeled_trainloader, unlabeled_trainloader, val_loader, test_loader, class_names, constants = \
sm.load_dataset(args)
ts, writer = sm.load_checkpoint(class_names, constants)
step = 0
# Train and val
for epoch in range(ts.start_epoch, constants['epochs']):
print('\nEpoch: [%d | %d]' % (epoch + 1, constants['epochs']))
step = constants['train_iteration'] * (epoch + 1)
if constants['enable_mixmatch']:
train_loss = train(labeled_trainloader, unlabeled_trainloader,
epoch, ts)
else:
train_loss = train_supervised(labeled_trainloader, epoch, ts)
losses, accs, confs, names = validate_all(labeled_trainloader,
val_loader, test_loader,
train_loss, ts)
tensorboard_write(writer, losses, accs, confs, names, class_names,
step)
# save model and other training variables
sm.save_checkpoint(accs[names['validation']], epoch)
sm.close()
'http://pow7.com:80/announce', 'http://open.acgnxtracker.com:80/announce',
'http://mail2.zelenaya.net:80/announce',
'udp://tracker4.itzmx.com:2710/announce',
'udp://tracker2.itzmx.com:6961/announce',
'udp://tr.bangumi.moe:6969/announce', 'udp://bt2.54new.com:8080/announce',
'https://tracker.hama3.net:443/announce',
'http://tracker4.itzmx.com:2710/announce',
'http://tracker2.itzmx.com:6961/announce',
'http://tracker.gcvchp.com:2710/announce',
'http://tracker.acgnx.se:80/announce', 'http://t.acg.rip:6699/announce'
]
bot_token = os.getenv('BOT_TOKEN')
api_id = int(os.getenv('API_ID'))
api_hash = os.getenv('API_HASH')
session_manager = SessionManager()
client = TelegramClient('toby', api_id, api_hash)
bot = TelegramClient('bot', api_id, api_hash).start(bot_token=bot_token)
in_progress_users = set()
tasks = dict()
pending_torrents = dict()
l = _log.new_logger()
class File():
def __init__(self, file_info):
self.fullpath = file_info[0]
self.num_pieces = file_info[1][0]
self.size = file_info[1][1]
''' Created on Mar 6, 2013 @author: lyb ''' import redis from settings.settings import REDIS_DB, REDIS_PORT, REDIS_HOST from users.UserManager import BLUserManager from session import SessionManager, login_required from contacts.ContactManager import BLIVManager from contacts.GroupManager import BLGroupManager rdb = redis.Redis(host=REDIS_HOST, port=REDIS_PORT, db=REDIS_DB) sm = SessionManager() im = BLIVManager() gm = BLGroupManager() um = BLUserManager()
def get_session_manager(self):
if self._session_manager is None:
self._session_manager = SessionManager(self)
return self._session_manager
