def test_config_update(self, _, mock: Mock):
mock.return_value = 2
conf = Config()
mock.return_value = 10
self.assertEqual(True, conf.check_config_update())
conf.update_config()
self.assertEqual(10, conf.last_modification)
def SetAllSoundFxObjectVolumes(
self, volume=None
): # MFH - single function to go through all sound objects (and iterate through all sound lists) and set object volume to the given volume
# MFH TODO - set every sound object's volume here...
if volume is None:
self.sfxVolume = Config.get("audio", "SFX_volume")
self.crowdVolume = Config.get("audio", "crowd_volume")
volume = self.sfxVolume
self.starDingSound.setVolume(volume)
self.bassDrumSound.setVolume(volume)
self.T1DrumSound.setVolume(volume)
self.T2DrumSound.setVolume(volume)
self.T3DrumSound.setVolume(volume)
self.CDrumSound.setVolume(volume)
for s in self.acceptSounds:
s.setVolume(volume)
for s in self.cancelSounds:
s.setVolume(volume)
self.rockSound.setVolume(volume)
self.starDeActivateSound.setVolume(volume)
self.starActivateSound.setVolume(volume)
self.battleUsedSound.setVolume(volume)
self.rescueSound.setVolume(volume)
self.coOpFailSound.setVolume(volume)
self.crowdSound.setVolume(self.crowdVolume)
self.starReadySound.setVolume(volume)
self.clapSound.setVolume(volume)
self.failSound.setVolume(volume)
self.starSound.setVolume(volume)
self.startSound.setVolume(volume)
self.selectSound1.setVolume(volume)
self.selectSound2.setVolume(volume)
self.selectSound3.setVolume(volume)
def SetAllSoundFxObjectVolumes(
self,
volume=None
): #MFH - single function to go through all sound objects (and iterate through all sound lists) and set object volume to the given volume
#MFH TODO - set every sound object's volume here...
if volume is None:
self.sfxVolume = Config.get("audio", "SFX_volume")
self.crowdVolume = Config.get("audio", "crowd_volume")
volume = self.sfxVolume
self.starDingSound.setVolume(volume)
self.bassDrumSound.setVolume(volume)
self.T1DrumSound.setVolume(volume)
self.T2DrumSound.setVolume(volume)
self.T3DrumSound.setVolume(volume)
self.CDrumSound.setVolume(volume)
for s in self.acceptSounds:
s.setVolume(volume)
for s in self.cancelSounds:
s.setVolume(volume)
self.rockSound.setVolume(volume)
self.starDeActivateSound.setVolume(volume)
self.starActivateSound.setVolume(volume)
self.battleUsedSound.setVolume(volume)
self.rescueSound.setVolume(volume)
self.coOpFailSound.setVolume(volume)
self.crowdSound.setVolume(self.crowdVolume)
self.starReadySound.setVolume(volume)
self.clapSound.setVolume(volume)
self.failSound.setVolume(volume)
self.starSound.setVolume(volume)
self.startSound.setVolume(volume)
self.selectSound1.setVolume(volume)
self.selectSound2.setVolume(volume)
self.selectSound3.setVolume(volume)
def test2(self):
c = Config()
c.from_dict({
'static_files': {
'root':'/path/to/root/',
'filter':'*.jpg'
},
'users':{
'id_property':'email',
'data_dir':'/data/system/userdata/'
},
})
self.assertDictEqual(c['users'], {
'id_property':'email',
'data_dir':'/data/system/userdata/'
})
self.assertDictEqual(c['static_files'], {
'root':'/path/to/root/',
'filter':'*.jpg'
})
def print_model_summary(network):
sample_inputs = tf.random.normal(shape=(Config.batch_size,
Config.get_image_size()[0],
Config.get_image_size()[1],
Config.image_channels))
sample_outputs = network(sample_inputs, training=True)
network.summary()
class ConfigDialog(QtGui.QDialog):
def __init__(self, parent=None):
"""Initializes the Dialog"""
self.logger = logging.getLogger('pymetadatamanager.configuration_dialog')
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_ConfigDialog()
self.ui.setupUi(self)
self.config = Config()
self.ui.lineEdit_tv_dirs.setText(",".join(self.config.tv_dirs))
self.ui.lineEdit_movie_dirs.setText(",".join(self.config.movie_dirs))
self.ui.checkBox_prefer_local.setChecked(self.config.prefer_local)
self.ui.lineEdit_mediainfo_path.setText(self.config.mediainfo_path)
self.ui.pushButton_tv_browse.clicked.connect(self.tv_browser)
self.ui.pushButton_movie_browse.clicked.connect(self.movie_browser)
self.ui.pushButton_mediainfo_browse.clicked.connect(self.mediainfo_browser)
self.ui.buttonBox.accepted.connect(self.save_values)
def tv_browser(self):
old_filename = self.ui.lineEdit_tv_dirs.text()
filename = QtGui.QFileDialog.getExistingDirectory(self, "TV Directory", \
old_filename)
if not filename == '':
self.ui.lineEdit_tv_dirs.setText(filename)
else:
self.ui.lineEdit_tv_dirs.setText(old_filename)
def movie_browser(self):
old_filename = self.ui.lineEdit_movie_dirs.text()
filename = QtGui.QFileDialog.getExistingDirectory(self, "Movie Directory", \
old_filename)
if not filename == '':
self.ui.lineEdit_movie_dirs.setText(filename)
else:
self.ui.lineEdit_movie_dirs.setText(old_filename)
def mediainfo_browser(self):
old_path = self.ui.lineEdit_mediainfo_path.text()
path = QtGui.QFileDialog.getOpenFileName(self, \
"MediaInfo Path", \
os.path.expanduser("~"))
if not path == '':
self.ui.lineEdit_mediainfo_path.setText(path)
else:
self.ui.lineEdit_mediainfo_path.setText(old_path)
def save_values(self):
del self.config.tv_dirs[:]
for dir in str(self.ui.lineEdit_tv_dirs.text()).split(","):
self.config.tv_dirs.append(dir)
del self.config.movie_dirs[:]
for dir in str(self.ui.lineEdit_movie_dirs.text()).split(","):
self.config.movie_dirs.append(dir)
self.config.mediainfo_path = self.ui.lineEdit_mediainfo_path.text()
if self.ui.checkBox_prefer_local.isChecked():
self.config.prefer_local = 1
else:
self.config.prefer_local = 0
self.config.write_config_file()
def init(engine):
# define configuration keys for all available mods
for m in getAvailableMods(engine):
Config.define("mods", "mod_" + m, bool, False, text = m, options = {False: _("Off"), True: _("On")})
# init all active mods
for m in getActiveMods(engine):
activateMod(engine, m)
def setup(self):
""""preform basic configuration, create the Config object which enables configuration to preform
configuration with usage of config.json"""
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
self.config = Config()
self.config.start()
self.client = Client(self.config)
self.agentLog = collector.AgentLogCollector()
logging.info("Agent initialized successfully!")
def get_dbcon():
db = MySQLdb.connect(host=Config.get('Database', 'Host'),
user=Config.get('Database', 'User'),
passwd=Config.get('Database', 'Password'),
db=Config.get('Database', 'Database'),
charset='utf8')
cur = db.cursor()
cur.execute('SET NAMES utf8mb4')
return db, cur
def build_default(deployment_home, cwd, CommandClasses):
"""
Create a runtime from the command line arguments and configuration on
disk.
If you want something more custom, e.g. in testing, you can build
it yourself ;)
"""
if len(CommandClasses):
arg_parser = CommandClasses[0].build_arg_parser()
else:
arg_parser = Runtime.__create_placeholder_arg_parser()
Runtime.add_default_arguments(arg_parser)
runtime = Runtime()
for CommandClass in CommandClasses:
CommandClass.register_services(runtime)
for ServiceClass in runtime.each_service_class():
add_default_arguments_method = getattr(ServiceClass,
'add_default_arguments',
None)
if add_default_arguments_method and callable(
add_default_arguments_method):
ServiceClass.add_default_arguments(arg_parser)
options = arg_parser.parse_args()
if not hasattr(options, 'deployment_home'):
options.deployment_home = deployment_home
config = Config()
config.set_options(options)
config.set_cwd(cwd)
if hasattr(CommandClass, 'DOTFILE_NAME'):
config.set_dotfile_name(CommandClass.DOTFILE_NAME)
try:
config.read()
except Exception as e:
if not hasattr(
CommandClass,
'is_config_required') or CommandClass.is_config_required():
exc_info = sys.exc_info()
raise e, None, exc_info[2]
log = Log()
log.set_options(options)
runtime.set_options(options)
runtime.set_config(config)
runtime.set_log(log)
runtime.set_cwd(cwd)
return runtime
def on_mainWindow_delete_event(self, widget, event): # leave edit mode and persist configs to database commands.leave_edit_mode(self) # persist config to config file Config.persist() # close Database if DB.close() == True: return False else: return True
def setup_logging():
verbose = Config.getboolean('Logging', 'VerboseStdout')
console = logging.StreamHandler()
console.setLevel(logging.INFO if verbose else logging.WARNING)
logfile = logging.FileHandler(Config.get('Logging', 'Logfile'))
logfile.setLevel(logging.INFO)
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO,
handlers=[console, logfile])
def find_facility(board, scanner_index):
target: Scanner or None = None
for sb, si in Config.getScanners().items():
if si.board == board and si.scannerIndex == scanner_index:
target = si
break
if target is not None:
for fn, fv in Config.getFacilities().items():
if fv.scanner == target or fv.outscanner == target:
return fv, fv.scanner if fv.scanner == target else fv.outscanner
else:
return None, None
class Wrapper(object):
def __init__(self, config=None, file=None):
if config:
self.config = config
elif file:
self.config = Config(file)
def disabled(self):
self.config.disable()
def output(self, line):
print self.config.format(line)
def __init__(self):
self.config = Config()
self.__running = True
import os
os.environ['SDL_VIDEO_CENTERED'] = '1'
self.__screen = pygame.display.set_mode(
self.config.get(self.config.RESOLUTION))
if self.config.get(self.config.FULLSCREEN):
self.toggle_fullscreen()
pygame.display.set_caption("ISN Project")
self.__clock = pygame.time.Clock()
self.__dtime = 0
self.__scene = Scenes.test_scene.SceneTest(self)
def test6(self):
s = Config()
s.from_dict({
'root':'/path/to/root/',
'filter':'*.jpg'
})
c = Config()
c['static_files'] = s
self.assertDictEqual(c.get('static_files'), {
'root':'/path/to/root/',
'filter':'*.jpg'
})
def changeconfiguration():
section = request.form.get('section')
key = request.form.get('key')
value = request.form.get('value')
# solution for checkboxes
if value is None:
value = "False"
Config.update(section, key, value)
# check if logging changed
if section == "logging":
deque_handler.setnrentries(int(Config.get('logging', 'maxlogentries')))
return redirect(url_for('.showconfiguration'))
def loadControls():
global controllerDict
controllers = []
allcontrollers = VFS.listdir(controlpath)
default = ["defaultd.ini", "defaultg.ini", "defaultm.ini"]
for name in allcontrollers:
if name.lower().endswith(".ini") and len(name) > 4:
if name in default:
continue
controllers.append(name[0:len(name)-4])
i = len(controllers)
controllerDict = dict([(str(controllers[n]),controllers[n]) for n in range(0, i)])
controllerDict["defaultg"] = _("Default Guitar")
controllerDict["defaultd"] = _("Default Drum")
defMic = None
if Microphone.supported:
controllerDict["defaultm"] = _("Default Microphone")
defMic = "defaultm"
tsControl = _("Controller %d")
tsControlTip = _("Select the controller for slot %d")
i = 1
Config.define("game", "control0", str, "defaultg", text = tsControl % 1, options = controllerDict, tipText = tsControlTip % 1)
controllerDict[_("None")] = None
Config.define("game", "control1", str, "defaultd", text = tsControl % 2, options = controllerDict, tipText = tsControlTip % 2)
Config.define("game", "control2", str, defMic, text = tsControl % 3, options = controllerDict, tipText = tsControlTip % 3)
Config.define("game", "control3", str, None, text = tsControl % 4, options = controllerDict, tipText = tsControlTip % 4)
def __init__(self):
"""
"""
self.testStartTime = datetime.fromtimestamp(
time.time()).strftime('%Y-%m-%d_%H-%M')
self.testEndingTime = ""
# Create tester instance
parameters = Config.XmlLib.ParseXml(
ROOT_PATH + os.sep + "configuration" + os.sep +
"{}.xml".format("CONFIG_SET"), "MAIN_BOARD")
# Config logger level for system module
loggerInfo = Config.XmlLib.ParseXml(
ROOT_PATH + os.sep + "configuration" + os.sep +
"{}.xml".format("CONFIG_SET"), "LOGGER_INFO")
self.logger = LoggerEx.ConfigLoggerEx(
'CTRL', loggerInfo['MOD_LOG_LEVEL']['CTRL'], LOG_FILE_NAME,
loggerInfo['FORMAT']['FILE'], loggerInfo['FORMAT']['CONSOLE'])
# Import configuration from XML file
self.logger.info("\nImport configuration from XML file:")
self.config = Config.XmlLib(self.logger,
ROOT_PATH + os.sep + "configuration")
self.logger.info("")
def showsubscriptions():
subscriptions = semanticEnrichment.get_subscriptions()
return render_template(
'subscriptions.html',
subscriptions=subscriptions.values(),
id=str(uuid.uuid4()),
endpoint=Config.getEnvironmentVariable('SE_CALLBACK'))
class EventType:
ARRIVAL = -1
#Silly implementation, find a workaround
SERVICE_FINISH = []
config = Config('perfsim.config')
NUM_SERVER = config.NUM_SERVER
for i in range(0, NUM_SERVER):
SERVICE_FINISH.append(i)
#NOTE : Service finish may or may not mean departure
def type_from_num(self, queue_number):
#This function will always be called with queue number
#For zeroth row, the event is SERVICE_FINISH[1]
return EventType.SERVICE_FINISH[queue_number]
def queue_from_event(self, etype):
'''
Right now, the enumeration is simple. The queue associated with
SERVICE_FINISH[i] is i - 1
'''
return etype
def name(self, number):
if (number == -1):
return "ARRIVAL"
else:
return "SERVICE_FINISH Q" + str(number)
name = classmethod(name)
type_from_num = classmethod(type_from_num)
queue_from_event = classmethod(queue_from_event)
def _subscribe_forTypeId(ngsi_type, entityId, sublist):
logger.debug("Subscribe for " + str(ngsi_type) + " " + str(entityId))
# check if subscription already in sublist
# solution is not optimal... but no other option at the moment
if entityId:
for key, value in sublist.items():
sub = value.subscription
try:
tmposid = sub['entities'][0]['id']
if tmposid == entityId:
logger.debug("Subscription for " + tmposid +
" already existing!")
return
except KeyError:
pass
# create subscription
filename = ""
if ngsi_type is ngsi_parser.NGSI_Type.Sensor:
filename = 'static/json/subscription_sensor.json'
elif ngsi_type is ngsi_parser.NGSI_Type.IoTStream:
filename = 'static/json/subscription_iotstream.json'
elif ngsi_type is ngsi_parser.NGSI_Type.StreamObservation:
filename = 'static/json/subscription_streamobservation.json'
with open(filename) as jFile:
subscription = json.load(jFile)
subscription['id'] = subscription['id'] + str(uuid.uuid4())
# replace callback
subscription['notification']['endpoint'][
'uri'] = Config.getEnvironmentVariable('SE_CALLBACK')
# set entity to subscribe to
if entityId:
subscription['entities'][0]['id'] = entityId
_add_subscription(subscription, sublist)
def draw_boxes_on_image(image, boxes, scores, classes):
idx2class_dict = Config.idx2class()
num_boxes = boxes.shape[0]
for i in range(num_boxes):
class_and_score = "{}: {:.3f}".format(str(idx2class_dict[classes[i]]),
scores[i])
cv2.rectangle(img=image,
pt1=(boxes[i, 0], boxes[i, 1]),
pt2=(boxes[i, 2], boxes[i, 3]),
color=(250, 206, 135),
thickness=2)
text_size = cv2.getTextSize(text=class_and_score,
fontFace=cv2.FONT_HERSHEY_SIMPLEX,
fontScale=0.5,
thickness=1)
text_width, text_height = text_size[0][0], text_size[0][1]
cv2.rectangle(img=image,
pt1=(boxes[i, 0], boxes[i, 1]),
pt2=(boxes[i, 0] + text_width,
boxes[i, 1] - text_height),
color=(203, 192, 255),
thickness=-1)
cv2.putText(img=image,
text=class_and_score,
org=(boxes[i, 0], boxes[i, 1] - 2),
fontFace=cv2.FONT_HERSHEY_SIMPLEX,
fontScale=0.5,
color=(0, 0, 0),
thickness=1)
return image
def _initialise_subscriptions(subscriptions):
# first get active subscriptions
_get_active_subscriptions(subscriptions)
# iterate list and check for IotStream, StreamObservation, Sensor subscription, if not found subscribe
for t in (ngsi_parser.NGSI_Type.IoTStream, ngsi_parser.NGSI_Type.Sensor,
ngsi_parser.NGSI_Type.StreamObservation):
subscribe = True
for key, value in subscriptions.items():
sub = value.subscription
try:
if ngsi_parser.get_type(sub['entities'][0]) is t:
# it is of type IotStream, check if it is our endpoint
if sub['notification']['endpoint'][
'uri'] == Config.getEnvironmentVariable(
'SE_CALLBACK'):
logger.debug("Subscription for " + str(t) +
" already existing!")
subscribe = False
break
except KeyError:
pass
if subscribe:
logger.debug("Initialise system with subscription for " + str(t))
_subscribe_forTypeId(t, None, subscriptions)
def users():
return "Disabled for now"
page = request.args['page'] if 'page' in request.args else 1
try:
page = int(page)
except:
page = 1
page = max(1, page)
perPage = 200
g.dbsession = Config.ScopedSession()
now = datetime.now(utc)
total = g.dbsession.query(Credential).filter(Credential.expiration > now).count()
pages = ceil(total / perPage)
page = min(pages, page)
pagerange = range(max(0, page - 3) + 1, min(pages, page + 2) + 1)
members = g.dbsession.query(Credential).filter(Credential.expiration > now)\
.order_by(Credential.memberid)\
.order_by(Credential.priority)\
.order_by(Credential.expiration).offset((page - 1) * perPage).limit(perPage).all()
membersgrouped = dict((k,list(v)) for k,v in groupby(members, lambda m : m.memberid))
for k,v in membersgrouped.items():
#blah = list(v)
print(k,len(list(v)))
return render_template('users.html', activity=activity, members=membersgrouped,ctx="users",page=page, pages=pages,pagerange=pagerange)
def setPriority(self, pid=None, priority=2):
""" Set The Priority of a Windows Process. Priority is a value between 0-5 where
2 is normal priority. Default sets the priority of the current
python process but can take any valid process ID. """
import win32api, win32process, win32con
priorityClasses = [
win32process.IDLE_PRIORITY_CLASS,
win32process.BELOW_NORMAL_PRIORITY_CLASS,
win32process.NORMAL_PRIORITY_CLASS,
win32process.ABOVE_NORMAL_PRIORITY_CLASS,
win32process.HIGH_PRIORITY_CLASS,
win32process.REALTIME_PRIORITY_CLASS
]
threadPriorities = [
win32process.THREAD_PRIORITY_IDLE,
#win32process.THREAD_PRIORITY_ABOVE_IDLE,
#win32process.THREAD_PRIORITY_LOWEST,
win32process.THREAD_PRIORITY_BELOW_NORMAL,
win32process.THREAD_PRIORITY_NORMAL,
win32process.THREAD_PRIORITY_ABOVE_NORMAL,
win32process.THREAD_PRIORITY_HIGHEST,
win32process.THREAD_PRIORITY_TIME_CRITICAL
]
pid = win32api.GetCurrentProcessId()
tid = win32api.GetCurrentThread()
handle = win32api.OpenProcess(win32con.PROCESS_ALL_ACCESS, True, pid)
win32process.SetPriorityClass(handle, priorityClasses[priority])
win32process.SetThreadPriority(tid, threadPriorities[priority])
if Config.get('performance', 'restrict_to_first_processor'):
win32process.SetProcessAffinityMask(handle, 1)
def cmd_pq(update: Update, context: CallbackContext):
ci, fro, fron, froi = cifrofron(update)
msg = update.message
if (not msg.reply_to_message) or (msg.reply_to_message.from_user.id !=
context.bot.id):
cmdreply(context.bot, ci, '<send that as a reply to my message!>')
return
repl = msg.reply_to_message
replid = repl.message_id
if (repl.sticker or not repl.text):
cmdreply(context.bot, ci, '<only regular text messages are supported>')
return
if (replid in pqed_messages) or (already_pqd(repl.text)):
cmdreply(context.bot, ci, '<message already forwarded>')
return
if replid in command_replies:
cmdreply(context.bot, ci, '<that is a silly thing to forward!>')
return
if pq_limit_check(froi) >= 5:
cmdreply(context.bot, ci, '<slow down a little!>')
return
context.bot.forwardMessage(chat_id=Config.get('Telegram', 'QuoteChannel'),
from_chat_id=ci,
message_id=replid)
pqed_messages.add(replid)
log_pq(ci, froi, repl.text)
def run(self):
self.reload_boards()
for api in self.authModules:
try:
api.refresh_database()
except Exception as e:
logger.error(
f"Failed to refresh database, module: {api.__module__}, e: {e}"
)
while self._run:
try:
r = self._inqueue.get(block=True, timeout=60)
except Empty:
# Do our AWS checks
for api in self.authModules:
try:
api.refresh_database()
except Exception as e:
logger.error(
f"Failed to refresh database, module: {api.__module__}, e: {e}"
)
continue
if type(r) == tuple:
if r[0] == 'unlock':
(c, board, relay, duration, credential) = r
self.boards[board].Unlock(relay, duration, credential)
elif r[0] == "lock":
(a, board, relay, credential) = r
self.boards[board].Lock(relay, credential)
elif r[0] == 'aws':
for api in self.authModules:
api.refresh_database()
elif r[0] == "status":
fv: Facility
# def facilityStatus(f : Facility):
# return self.boards[f.board].relaystatus[f.relay]
status = dict(
(f.name, self.boards[f.board].relaystatus[f.relay])
for f in Config.Facilities.values())
# status = list(map(facilityStatus,Config.Facilities.values()))
self._outqueue.put(status)
elif r[0] == "query":
response = []
bv: ReaderBoard
for bn, bv in self.boards.items():
response.append(bv.__repr__())
for bv in query_devices(
ignored_devices=self.boards.values()):
response.append(bv)
self._outqueue.put(response)
elif r[0] == "reload":
# We have to do this here, even though it's also done in the webpanel, because
# Config is different here vs webpanel due to multiprocessing
Config.Reload()
self.reload_boards()
for api in self.authModules:
api.on_close()
self.authModules = self.load_authorizations()
self._outqueue.put("OK")
def __init__(self,
target,
name,
function,
resultQueue,
loaderSemaphore,
onLoad=None,
onCancel=None):
Thread.__init__(self)
self.semaphore = loaderSemaphore
self.target = target
self.name = name
self.function = function
self.resultQueue = resultQueue
self.result = None
self.onLoad = onLoad
self.onCancel = onCancel
self.exception = None
self.time = 0.0
self.canceled = False
#myfingershurt: the following should be global and done ONCE:
self.logLoadings = Config.get("game", "log_loadings")
if target and name:
setattr(target, name, None)
def init(engine):
# define configuration keys for all available mods
for m in getAvailableMods(engine):
Config.define("mods",
"mod_" + m,
bool,
False,
text=m,
options={
False: _("Off"),
True: _("On")
})
# init all active mods
for m in getActiveMods(engine):
activateMod(engine, m)
class Password:
def __init__(self):
self.encryption_key = Config().get_secret()
if self.encryption_key is None:
self.set_encryption_key()
else: # just take what's given
self.cipher = Fernet(self.encryption_key)
def get_encryption_key(self):
return self.encryption_key
def set_encryption_key(self):
self.encryption_key = Fernet.generate_key()
Config().set_secret(self.encryption_key.decode()) # store as string
# Don't forget to update the cipher!!!
self.cipher = Fernet(self.encryption_key)
def encrypt(self, plain_password):
return self.cipher.encrypt(plain_password.encode())
def decrypt(self, encrypted_password):
try:
return self.cipher.decrypt(encrypted_password).decode()
except InvalidToken:
return "ERROR: Invalid Encryption Key"
@staticmethod
def generate(mn=16, mx=64):
return ''.join(
choice(ascii_letters + digits) for _ in range(randint(mn, mx)))
async def get_ts_daily_adjusted(symbol: str, config: Config, cache: bool = True) -> pd.DataFrame:
"""Returns time series data for the given symbol using the Alpha Vantage api in an
async method."""
ts = TimeSeries(key=config.get('key', 'ALPHA_VANTAGE'),
output_format='pandas')
try:
data, _ = await ts.get_daily_adjusted(symbol, outputsize='full')
except ValueError as e:
if 'higher API call' in str(e):
raise ce.RateLimited
elif 'Invalid API call' in str(e):
raise ce.UnknownAVType
else:
raise
idx = pd.date_range(min(data.index), max(data.index))
data = data.reindex(idx[::-1])
data['4. close'].fillna(method='backfill', inplace=True)
data['5. adjusted close'].fillna(method='backfill', inplace=True)
data['6. volume'].fillna(0.0, inplace=True)
data['7. dividend amount'].fillna(0.0, inplace=True)
data.apply(lambda x: x.fillna(data['4. close'], inplace=True)
if x.name in ['1. open',
'2. high',
'3. low']
else x.fillna(1.0, inplace=True))
data.index.name = 'date'
data = meta_label_columns(data, symbol)
if cache:
save_data(name_generator(
symbol, IngestTypes.TimeSeriesDailyAdjusted), data)
await ts.close()
return data
async def get_cc_daily(symbol: str, config: Config, market: str = 'USD',
sanitize: bool = True, cache: bool = True) -> pd.DataFrame:
"""Returns CryptoCurrency data for the given symbol using the Alpha Vantage api in an
async method."""
cc = CryptoCurrencies(key=config.get('key', 'ALPHA_VANTAGE'),
output_format='pandas')
try:
data, _ = await cc.get_digital_currency_daily(symbol, market)
except ValueError as e:
if 'higher API call' in str(e):
raise ce.RateLimited
elif 'Invalid API call' in str(e):
raise ce.UnknownAVType
else:
raise
if sanitize:
data = data[~(data.index >= datetime.now().date().strftime('%Y%m%d'))]
cols = [x for x in data.columns if 'b. ' in x]
data = data.drop(cols, axis=1)
data = meta_label_columns(data, symbol)
if cache:
save_data(name_generator(
symbol, IngestTypes.CryptoCurrenciesDaily), data)
await cc.close()
return data
def __init__(self, batch_labels):
self.downsampling_ratio = Config.downsampling_ratio #获取网络输出的大小与网络输入的下降率
self.features_shape = np.array(
Config.get_image_size(),
dtype=np.int32) // self.downsampling_ratio #变成网络输出大小
self.batch_labels = batch_labels #batch 标签信息
self.batch_size = batch_labels.shape[0] #batch的大小
def setPriority(self, pid = None, priority = 2):
""" Set The Priority of a Windows Process. Priority is a value between 0-5 where
2 is normal priority. Default sets the priority of the current
python process but can take any valid process ID. """
import win32api, win32process, win32con
priorityClasses = [win32process.IDLE_PRIORITY_CLASS,
win32process.BELOW_NORMAL_PRIORITY_CLASS,
win32process.NORMAL_PRIORITY_CLASS,
win32process.ABOVE_NORMAL_PRIORITY_CLASS,
win32process.HIGH_PRIORITY_CLASS,
win32process.REALTIME_PRIORITY_CLASS]
threadPriorities = [win32process.THREAD_PRIORITY_IDLE,
#win32process.THREAD_PRIORITY_ABOVE_IDLE,
#win32process.THREAD_PRIORITY_LOWEST,
win32process.THREAD_PRIORITY_BELOW_NORMAL,
win32process.THREAD_PRIORITY_NORMAL,
win32process.THREAD_PRIORITY_ABOVE_NORMAL,
win32process.THREAD_PRIORITY_HIGHEST,
win32process.THREAD_PRIORITY_TIME_CRITICAL]
pid = win32api.GetCurrentProcessId()
tid = win32api.GetCurrentThread()
handle = win32api.OpenProcess(win32con.PROCESS_ALL_ACCESS, True, pid)
win32process.SetPriorityClass(handle, priorityClasses[priority])
win32process.SetThreadPriority(tid, threadPriorities[priority])
if Config.get('performance', 'restrict_to_first_processor'):
win32process.SetProcessAffinityMask(handle, 1)
def _get_hot_slice_by_threads(rlbb, nav_slice):
ops_and_scores = rlbb.with_scores[nav_slice] if rlbb else []
ops = [Comment(id=id) for (id, score) in ops_and_scores]
max_from_thread = 3
# Got the OPs, now I need to bulk fetch the top replies.
pipeline = redis.pipeline()
for comment in ops:
pipeline.get(comment.redis_score.key)
for comment in ops:
pipeline.zrevrange(comment.popular_replies.key, 0, max_from_thread - 1, withscores=True)
results = pipeline.execute()
op_scores, pop_reply_lists = results[:len(ops)], results[len(ops):]
ids = []
if ops_and_scores:
# Lowest score sets the threshold, but replies get a "boost" factor
cutoff = ops_and_scores[-1][1] / Config.get('reply_boost', 1)
for op, op_score, pop_replies in zip(ops, op_scores, pop_reply_lists):
items = [(int(id), float(score or 0)) for (id,score) in [(op.id, op_score)] + pop_replies]
items.sort(key=lambda (id, score): -score)
ids += [id for (id, score) in items if score >= cutoff][:max_from_thread]
return ids
def test_passenger_generation():
"""Tests passenger generation"""
config_name = get_full_class_name(Config)
with patch(config_name + '.graph_dict',
new_callable=PropertyMock) as mock_graph_dict:
with patch(config_name + '.lines_dict',
new_callable=PropertyMock) as mock_lines_dict:
with patch(config_name + '.traffic_data_dict',
new_callable=PropertyMock) as mock_traffic_dict:
mock_graph_dict.return_value = {
'A': [('B', 1)],
'B': [('A', 1)]
}
mock_lines_dict.return_value = {
0: {
'id': 0,
'bus_capacity': 1,
'frequency1': 10000000,
'frequency2': 1000000000,
'route1': ['B', 'A'],
'route2': ['A', 'B']
}
}
config = Config(["A", "B"], {}, {}, {}, 1.0)
mock_traffic_dict.return_value = {
'A': {
'A': 0,
'B': 120
},
'B': {
'A': 0,
'B': 0
}
}
generated = []
model = []
simulation = Simulation(config)
print(config.lines_dict)
simulation.refresh()
simulation.refresh()
for i in range(100000):
simulation.refresh()
if simulation.stops['A'].passengers:
generated.append(
simulation.stops['A'].passengers[0].count)
for i in range(len(generated) - 1, 0, -1):
generated[i] -= generated[i - 1]
model.append(np.random.poisson(2))
model.append(np.random.poisson(2))
generated = np.sort(np.array(generated))
model = np.sort(np.array(model))
res = sum(np.abs(generated - model) != 0)
assert res / len(
generated) <= 0.02, " jak nie dziolo to odpalic od nowa i nie narzekac, " \
"bo tak naprawde dziala tylko czasem nie"
def main(image):
# Configuration for hyper-parameters
config = Config()
# Image Preprocessing
transform = config.test_transform
# Load vocabulary
with open(os.path.join(config.vocab_path, 'vocab.pkl'), 'rb') as f:
vocab = pickle.load(f)
# Build Models
encoder = EncoderCNN(config.embed_size)
encoder.eval() # evaluation mode (BN uses moving mean/variance)
decoder = DecoderRNN(config.embed_size, config.hidden_size, len(vocab),
config.num_layers)
# Load the trained model parameters
encoder.load_state_dict(
torch.load(
os.path.join(config.teacher_cnn_path, config.trained_encoder)))
decoder.load_state_dict(
torch.load(
os.path.join(config.teacher_lstm_path, config.trained_decoder)))
# Prepare Image
image = Image.open(image)
image_tensor = Variable(transform(image).unsqueeze(0))
# Set initial states
state = (Variable(torch.zeros(config.num_layers, 1, config.hidden_size)),
Variable(torch.zeros(config.num_layers, 1, config.hidden_size)))
# If use gpu
if torch.cuda.is_available():
encoder.cuda()
decoder.cuda()
state = [s.cuda() for s in state]
image_tensor = image_tensor.cuda()
# Generate caption from image
feature = encoder(image_tensor)
sampled_ids = decoder.sample(feature, state)
sampled_ids = sampled_ids.cpu().data.numpy()
# Decode word_ids to words
sampled_caption = []
for word_id in sampled_ids:
word = vocab.idx2word[word_id]
sampled_caption.append(word)
if word_id == 96:
sampled_caption.append('<end>')
break
if word == '<end>':
break
sentence = ' '.join(sampled_caption)
# Print out image and generated caption.
print(sentence)
return sentence
def build_default(deployment_home, cwd, CommandClasses):
"""
Create a runtime from the command line arguments and configuration on
disk.
If you want something more custom, e.g. in testing, you can build
it yourself ;)
"""
if len(CommandClasses):
arg_parser = CommandClasses[0].build_arg_parser()
else:
arg_parser = Runtime.__create_placeholder_arg_parser()
Runtime.add_default_arguments(arg_parser)
runtime = Runtime()
for CommandClass in CommandClasses:
CommandClass.register_services(runtime)
for ServiceClass in runtime.each_service_class():
add_default_arguments_method = getattr(ServiceClass, 'add_default_arguments', None)
if add_default_arguments_method and callable(add_default_arguments_method):
ServiceClass.add_default_arguments(arg_parser)
options = arg_parser.parse_args()
if not hasattr(options, 'deployment_home'):
options.deployment_home = deployment_home
config = Config()
config.set_options(options)
config.set_cwd(cwd)
if hasattr(CommandClass, 'DOTFILE_NAME'):
config.set_dotfile_name(CommandClass.DOTFILE_NAME)
try:
config.read()
except Exception as e:
if not hasattr(CommandClass, 'is_config_required') or CommandClass.is_config_required():
exc_info = sys.exc_info()
raise e, None, exc_info[2]
log = Log()
log.set_options(options)
runtime.set_options(options)
runtime.set_config(config)
runtime.set_log(log)
runtime.set_cwd(cwd)
return runtime
def setUp(self):
config = Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini", setAsDefault = True)
self.e = GameEngine(config)
self.e.loadImgDrawing(self, "svg", "mfhlogo.png")
while not self.svg:
self.e.run()
glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
def activateMod(engine, modName):
modPath = _getModPath(engine)
m = os.path.join(modPath, modName)
t = os.path.join(m, "theme.ini")
if os.path.isdir(m):
engine.resource.addDataPath(m)
if os.path.isfile(t):
theme = Config.load(t)
Theme.open(theme)
def testLoading(self):
config = Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini", setAsDefault = True)
e = GameEngine(config)
infoFile = e.resource.fileName("tutorials", "bangbang", "song.ini")
guitarFile = e.resource.fileName("tutorials", "bangbang", "guitar.ogg")
songFile = e.resource.fileName("tutorials", "bangbang", "song.ogg")
noteFile = e.resource.fileName("tutorials", "bangbang", "notes.mid")
song = Song(e, infoFile, guitarFile, songFile, None, noteFile)
assert int(song.bpm) == 120
def __init__(self, dataPath = os.path.join("..", "data")):
self.resultQueue = Queue()
self.dataPaths = [dataPath]
self.loaderSemaphore = BoundedSemaphore(value = 1)
self.loaders = []
#myfingershurt: the following should be global, and only done at startup. Not every damn time a file is loaded.
self.songPath = []
self.baseLibrary = Config.get("setlist", "base_library")
#evilynux - Support for songs in ~/.fretsonfire/songs (GNU/Linux and MacOS X)
if self.baseLibrary == "None" and os.name == "posix":
path = os.path.expanduser("~/." + Version.PROGRAM_UNIXSTYLE_NAME)
if os.path.isdir(path):
self.baseLibrary = path
Config.set("setlist", "base_library", path)
if self.baseLibrary and os.path.isdir(self.baseLibrary):
self.songPath = [self.baseLibrary]
self.logLoadings = Config.get("game", "log_loadings")
def test7(self):
c = Config()
c.from_dict({
'static_files': {
'root':'/path/to/root/',
'filter':'*.jpg'
},
'users':{
'id_property':'email',
'data_dir':'/data/system/userdata/'
},
})
self.assertEqual(c.static_files.root, '/path/to/root/')
self.assertEqual(c.static_files.filter, '*.jpg')
self.assertEqual(c.users['id_property'], 'email')
self.assertEqual(c.users['data_dir'], '/data/system/userdata/')
def test4(self):
c = Config()
c.from_dict({
'static_files': {
'root':'/path/to/root/',
'filter':'*.jpg'
},
'users':{
'id_property':'email',
'data_dir':'/data/system/userdata/'
},
})
s = c.sub('users')
self.assertEqual(s.get('id_property'), 'email')
self.assertEqual(s.get('data_dir'), '/data/system/userdata/')
def run(self):
self.semaphore.acquire()
game_priority = Config.get("performance", "game_priority")
# Reduce priority on posix
if os.name == "posix":
# evilynux - Beware, os.nice _decreases_ priority, hence the reverse logic
os.nice(5 - game_priority)
elif os.name == "nt":
self.setPriority(priority = game_priority)
self.load()
self.semaphore.release()
self.resultQueue.put(self)
def __init__(self, name, number):
self.logClassInits = Config.get("game", "log_class_inits")
if self.logClassInits == 1:
Log.debug("Player class init (Player.py)...")
self.name = name
self.reset()
self.keyList = None
self.progressKeys = []
self.drums = []
self.keys = []
self.soloKeys = []
self.soloShift = None
self.soloSlide = False
self.actions = []
self.yes = []
self.no = []
self.conf = []
self.up = []
self.down = []
self.left = []
self.right = []
self.controller = -1
self.controlType = -1
self.guitarNum = None
self.number = number
self.bassGrooveEnabled = False
self.currentTheme = 1
self.lefty = _playerDB.execute('SELECT `lefty` FROM `players` WHERE `name` = ?', [self.name]).fetchone()[0]
self.twoChordMax = _playerDB.execute('SELECT `twochord` FROM `players` WHERE `name` = ?', [self.name]).fetchone()[0]
self.drumflip = _playerDB.execute('SELECT `drumflip` FROM `players` WHERE `name` = ?', [self.name]).fetchone()[0]
self.assistMode = _playerDB.execute('SELECT `assist` FROM `players` WHERE `name` = ?', [self.name]).fetchone()[0]
self.autoKick = _playerDB.execute('SELECT `autokick` FROM `players` WHERE `name` = ?', [self.name]).fetchone()[0]
self.neck = _playerDB.execute('SELECT `neck` FROM `players` WHERE `name` = ?', [self.name]).fetchone()[0]
self.neckType = _playerDB.execute('SELECT `necktype` FROM `players` WHERE `name` = ?', [self.name]).fetchone()[0]
self.whichPart = _playerDB.execute('SELECT `part` FROM `players` WHERE `name` = ?', [self.name]).fetchone()[0]
self._upname = _playerDB.execute('SELECT `upname` FROM `players` WHERE `name` = ?', [self.name]).fetchone()[0]
self._difficulty = _playerDB.execute('SELECT `difficulty` FROM `players` WHERE `name` = ?', [self.name]).fetchone()[0]
#MFH - need to store selected practice mode and start position here
self.practiceMode = False
self.practiceSpeed = 1.0
self.practiceSection = None
self.startPos = 0.0
self.hopoFreq = None
def savePlayers():
for pref in _playerDB.execute('SELECT * FROM `players` WHERE `changed` = 1').fetchall():
try:
c = Config.load(VFS.resolveWrite(_makePlayerIniName(str(pref[0]))), type = 2)
c.set("player","leftymode",int(pref[1]))
c.set("player","drumflip",int(pref[2]))
c.set("player","auto_kick",int(pref[3]))
c.set("player","assist_mode",int(pref[4]))
c.set("player","two_chord_max",int(pref[5]))
c.set("player","necktype",int(pref[6]))
c.set("player","neck",str(pref[7]))
c.set("player","part",int(pref[8]))
c.set("player","difficulty",int(pref[9]))
c.set("player","name",str(pref[10]))
c.set("player","controller",int(pref[11]))
del c
_playerDB.execute('UPDATE `players` SET `changed` = 0 WHERE `name` = ?', [pref[0]])
except:
c = VFS.open(_makePlayerIniName(str(pref[0])), "w")
c.close()
c = Config.load(VFS.resolveWrite(_makePlayerIniName(str(pref[0]))), type = 2)
c.set("player","leftymode",int(pref[1]))
c.set("player","drumflip",int(pref[2]))
c.set("player","auto_kick",int(pref[3]))
c.set("player","assist_mode",int(pref[4]))
c.set("player","two_chord_max",int(pref[5]))
c.set("player","necktype",int(pref[6]))
c.set("player","neck",str(pref[7]))
c.set("player","part",int(pref[8]))
c.set("player","difficulty",int(pref[9]))
c.set("player","name",str(pref[10]))
c.set("player","controller",int(pref[11]))
del c
_playerDB.execute('UPDATE `players` SET `changed` = 0 WHERE `name` = ?', [pref[0]])
_playerDB.execute('UPDATE `players` SET `loaded` = 0')
_playerDB.commit()
def checkIfEnabled(self):
if Config.get("video","shader_use"):
if self.enabled:
self.turnon = True
else:
self.set(os.path.join(Version.dataPath(), "shaders"))
else:
self.turnon = False
if self.turnon:
for i in self.shaders.keys():
try:
value = Config.get("video","shader_"+i)
if value != "None":
if value == "theme":
if isTrue(Config.get("theme","shader_"+i).lower()):
value = i
else:
continue
self.assigned[i] = value
except KeyError:
continue
return True
return False
def setNewKeyMapping(engine, config, section, option, key):
oldKey = config.get(section, option)
config.set(section, option, key)
keyCheckerMode = Config.get("game", "key_checker_mode")
if key == "None" or key is None:
return True
b = isKeyMappingOK(config, option)
if b != 0:
if keyCheckerMode > 0:
from views import Dialogs
Dialogs.showMessage(engine, _("This key conflicts with the following keys: %s") % str(b))
if keyCheckerMode == 2: #enforce no conflicts!
config.set(section, option, oldKey)
return False
return True
def __init__(self, parent=None):
"""Initializes the Dialog"""
self.logger = logging.getLogger('pymetadatamanager.configuration_dialog')
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_ConfigDialog()
self.ui.setupUi(self)
self.config = Config()
self.ui.lineEdit_tv_dirs.setText(",".join(self.config.tv_dirs))
self.ui.lineEdit_movie_dirs.setText(",".join(self.config.movie_dirs))
self.ui.checkBox_prefer_local.setChecked(self.config.prefer_local)
self.ui.lineEdit_mediainfo_path.setText(self.config.mediainfo_path)
self.ui.pushButton_tv_browse.clicked.connect(self.tv_browser)
self.ui.pushButton_movie_browse.clicked.connect(self.movie_browser)
self.ui.pushButton_mediainfo_browse.clicked.connect(self.mediainfo_browser)
self.ui.buttonBox.accepted.connect(self.save_values)
def deleteControl(control):
VFS.unlink(_makeControllerIniName(control))
defaultUsed = -1
for i in range(4):
get = Config.get("game", "control%d" % i)
if get == control:
if i == 0:
Config.set("game", "control%d" % i, "defaultg")
defaultUsed = 0
else:
Config.set("game", "control%d" % i, None)
if get == "defaultg" and defaultUsed > -1:
Config.set("game", "control%d" % i, None)
loadControls()
def updateHandicapValue(self):
self.handicapValue = 100.0
slowdown = Config.get("audio","speed_factor")
earlyHitHandicap = 1.0 #self.earlyHitWindowSizeHandicap #akedrou - replace when implementing handicap.
for j in range(len(HANDICAPS)):
if (self.handicap>>j)&1 == 1:
if j == 1: #scalable
if slowdown != 1:
if slowdown < 1:
cut = (100.0**slowdown)/100.0
else:
cut = (100.0*slowdown)/100.0
self.handicapValue *= cut
if earlyHitHandicap != 1.0:
self.handicapValue *= earlyHitHandicap
else:
self.handicapValue *= HANDICAPS[j]
def testSaving(self):
config = Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini", setAsDefault = True)
e = GameEngine(config)
# Make a temp copy
tmp = "songtest_tmp"
files = ["song.ini", "guitar.ogg", "song.ogg", "notes.mid"]
try:
os.mkdir(tmp)
for f in files:
shutil.copy(e.resource.fileName("tutorials", "bangbang", f), tmp)
infoFile = os.path.join(tmp, "song.ini")
guitarFile = os.path.join(tmp, "guitar.ogg")
songFile = os.path.join(tmp, "song.ogg")
noteFile = os.path.join(tmp, "notes.mid")
song = Song(e, infoFile, guitarFile, songFile, None, noteFile)
events1 = song.track[0].getAllEvents()
song.save()
song = Song(e, infoFile, guitarFile, songFile, None, noteFile)
events2 = song.track[0].getAllEvents()
notes1 = [(time, event) for time, event in events1 if isinstance(event, Note)]
notes2 = [(time, event) for time, event in events2 if isinstance(event, Note)]
for i, event in enumerate(zip(notes1, notes2)):
t1, n1 = event[0]
t2, n2 = event[1]
if "-v" in sys.argv:
print "%8d. %.3f + %.3f\t%2d\t %.3f + %.3f\t%2d" % (i, t1, n1.length, n1.number, t2, n2.length, n2.number)
# Allow 2ms of rounding error
assert abs(t1 - t2) < 2
assert abs(n1.length - n2.length) < 2
assert n1.number == n2.number
finally:
# Load another song to free the copy
pygame.mixer.music.load(e.resource.fileName("tutorials", "bangbang", "guitar.ogg"))
shutil.rmtree(tmp)
def __init__(self, target, name, function, resultQueue, loaderSemaphore, onLoad = None, onCancel = None):
Thread.__init__(self)
self.semaphore = loaderSemaphore
self.target = target
self.name = name
self.function = function
self.resultQueue = resultQueue
self.result = None
self.onLoad = onLoad
self.onCancel = onCancel
self.exception = None
self.time = 0.0
self.canceled = False
#myfingershurt: the following should be global and done ONCE:
self.logLoadings = Config.get("game", "log_loadings")
if target and name:
setattr(target, name, None)
def loadPlayers():
global playername, playerpref, playerstat
playername = []
playerpref = []
playerstat = []
allplayers = VFS.listdir(playerpath)
for name in allplayers:
if name == "default.ini":
continue
if name.lower().endswith(".ini") and len(name) > 4:
playername.append(name[0:len(name)-4])
pref = _playerDB.execute('SELECT * FROM `players` WHERE `name` = ?', [playername[-1]]).fetchone()
try:
if len(pref) == 14:
playerpref.append((pref[1], pref[2], pref[3], pref[4], pref[5], pref[6], pref[7], pref[8], pref[9], pref[10]))
except TypeError:
try:
c = Config.load(VFS.resolveRead(_makePlayerIniName(name[:-4])), type = 2)
lefty = c.get("player","leftymode")
drumf = c.get("player","drumflip")
autok = c.get("player","auto_kick")
assist = c.get("player","assist_mode")
twoch = c.get("player","two_chord_max")
neck = c.get("player","neck")
neckt = c.get("player","necktype")
part = c.get("player","part")
diff = c.get("player","difficulty")
upname = c.get("player","name")
control= c.get("player","controller")
del c
_playerDB.execute('INSERT INTO `players` VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 1)', [playername[-1], lefty, drumf, autok, assist, twoch, neckt, neck, part, diff, upname, control])
playerpref.append((lefty, drumf, autok, assist, twoch, neckt, neck, part, diff, upname))
except IOError:
_playerDB.execute('INSERT INTO `players` VALUES (?, 0, 0, 0, 0, 0, 0, ``, 0, 2, ``, 0, 0, 1)', [playername[-1]])
playerpref.append((0, 0, 0, 0, 0, 0, '', 0, 2, '', 0))
_playerDB.execute('UPDATE `players` SET `loaded` = 1 WHERE `name` = ?', [playername[-1]])
_playerDB.commit()
return 1
def testNetworking(self):
config = Config.load(Version.PROGRAM_UNIXSTYLE_NAME + ".ini", setAsDefault = True)
e1 = GameEngine(config)
e1.startServer()
session1 = e1.connect("localhost")
session2 = e1.connect("localhost")
while not session1.isConnected() or not session2.isConnected():
e1.run()
session1.world.createPlayer("mario")
session2.world.createPlayer("luigi")
for i in range(10):
e1.run()
assert len(e1.server.world.players) == 2
assert len(session1.world.players) == 2
assert len(session2.world.players) == 2
session3 = e1.connect("localhost")
for i in range(10):
e1.run()
assert len(session3.world.players) == 2
session1.disconnect()
for i in range(10):
e1.run()
assert len(e1.server.world.players) == 1
assert len(session2.world.players) == 1
e1.quit()
def refreshBaseLib(self):
self.baseLibrary = Config.get("setlist", "base_library")
if self.baseLibrary and os.path.isdir(self.baseLibrary):
self.songPath = [self.baseLibrary]
