def __init__(self, *args, **kwargs):
QtGui.QMainWindow.__init__(self, *args, **kwargs)
self._app = Application.instance()
title = "ChromaClub"
if self._app.isTestNet:
title += " [testnet]"
title += " - " + clubAsset['monikers'][0]
self.setWindowTitle(title)
self.setWindowIcon(QtGui.QIcon(':icons/chromaclub.png'))
self.resize(900, 550)
self.move(Application.instance().desktop().screen().rect().center() - self.rect().center())
self.setCentralWidget(QtGui.QStackedWidget())
self.overviewpage = OverviewPage(self)
self.sendpage = SendPage(self)
self.chatpage = ChatPage(self)
self.centralWidget().addWidget(self.overviewpage)
self.centralWidget().addWidget(self.sendpage)
self.centralWidget().addWidget(self.chatpage)
self._create_actions()
self._create_menu_bar()
self._create_tool_bar()
self._create_status_bar()
self._create_tray_icon()
self._create_tray_icon_menu()
self._app.statusChanged.connect(self._status_changed)
def test_not_in_team(self):
# Mock Application.fetch_name_from_file
Application.fetch_name_from_file = mock.Mock()
Application.fetch_name_from_file.return_value = 'Krishna'
app = Application()
self.assertFalse(app.is_in_team())
def test_in_team(self):
# Mock Application.fetch_name_from_file
Application.fetch_name_from_file = mock.Mock()
Application.fetch_name_from_file.return_value = 'Apurva'
app = Application()
self.assertTrue(app.is_in_team())
def recibeVideo(self):
connection = Application.getInstance().getConnection()
while not self.closedInterface.is_set() and connection != None:
start = time.time()
frameTime = 1/self.fpsOutput
if connection.isRunning():
try:
msg = connection.rcv()
frame = msg['image']
self.fpsInput = msg['fps']
self.inputResolution = msg['resolution']
img_tk = ImageTk.PhotoImage(frame)
# Lo mostramos en el GUI
self.app.setImageData('receivedVideoImage', img_tk, fmt = 'PhotoImage')
self.app.setImageWidth('receivedVideoImage', self.inputResolution[0])
self.app.setImageHeight('receivedVideoImage', self.inputResolution[1])
self.app.setStatusbar('Recibiendo a {}x{}/{} fps.'.format(self.inputResolution[0], self.inputResolution[1], msg['fps']), field=0)
self.app.setStatusbar('Retraso de {:+.3f} segundos.'.format(time.time() - msg['timestamp']), field=1)
self.app.setStatusbar('Duracion de la llamada: {} segundos'.format(utils.timedeltaToStr(time.time() - self.timeCallStarted)), field=2)
except BlockingIOError as e:
# No recibimos datos
self.app.setImage('receivedVideoImage', 'imgs/user_icon.gif')
except TypeError as e:
# timeCallStarted es None por haber sido cambiado en otro hilo al cerrarse la llamada
pass
# Pausamos el tiempo necesario para cuadrar los fps
pauseTime = frameTime + start - time.time() # frameTime - (time.time() - start)
if pauseTime < 0:
continue
time.sleep(pauseTime)
connection = Application.getInstance().getConnection()
def login(self, button):
# Nos registramos / logeamos en el servidor de descubrimiento
password = self.app.getEntry('loginPasswordEntry')
if not password:
self.notifyLogin('Es necesario que introduzcas una contraseña.')
self.notifyLogin('Consultando información con el servidor.')
# Deshabilitamos los botones mientras consultamos en el servidor para evitar
# posibles errores al pulsar varias veces
self.app.queueFunction(self.app.disableButton, 'Register user')
self.app.queueFunction(self.app.disableButton, 'Login')
user = getUserInfo()
if user == None:
self.notifyLogin('Ha habido un error, el usuario no esta almacenado. Es necesario que se registre')
self.app.queueFunction(self.app.hideLabelFrame, 'Login')
return
tmp = identityGestion.registerUser(user.nick, user.ip, user.port, password, '#'.join(user.protocols))
if tmp != None:
# La contraseña es correcta, acabamos
Application.getInstance().setUser(tmp)
Application.getInstance().startControlConnection(tmp.ip, tmp.port)
# La conexión de control se encarga de mostrar o no la pantalla principal
else:
# Volvemos a habilitar los botones
self.app.queueFunction(self.app.enableButton, 'Register user')
self.app.queueFunction(self.app.enableButton, 'Login')
self.notifyLogin('La contraseña es incorrecta o el usuario ya no existe.')
def stop(self, signal=None, _=None):
# Al hacer sys.exit(0), es posible que el manejador de Ctrl+C llame a la funcion
# En ese caso, ya se habrá cerrado todo. Así evitamos fallos.
if self.closedInterface.is_set():
return True
print('Cerramos la aplicacion')
self.closedInterface.set()
try:
# Dejamos tiempo para que los hilos de mostrar video acaben
self.notify('Cerrando la aplicación.')
time.sleep(1)
# Liberamos el archivo de video usado
if not self.usingCamera.is_set():
self.cap.release()
connection = Application.getInstance().getConnection()
if connection != None:
user = connection.dstUser
# Colgamos la llamada con el usuario
self.notify('Finalizando la llamada.')
Application.getInstance().getControlConnection().endCall()
self.closeCallWindow()
self.notify('Cerrando la conexión de control.')
Application.getInstance().getControlConnection().quit()
self.app.queueFunction(sys.exit, 0)
return True
except Exception as e:
self.logger.exception('VideoClient - Error al cerrar: '+str(e))
self.app.queueFunction(sys.exit, 0)
def main():
LogHelper.start_logging("logdownloader.log")
parser = argparse.ArgumentParser(
description="AWS bootstrapper log downloader" +
"Downloads instances logs from AWS S3")
parser.add_argument(
"--manifestPath",
help=
"path to a manifest file describing the jobs and data requirements for the application",
required=True)
parser.add_argument("--outputPath",
help="directory to where instance logs will be copied",
required=True)
try:
args = vars(parser.parse_args())
manifestPath = os.path.abspath(args["manifestPath"])
outputdir = os.path.abspath(args["outputPath"])
s3 = boto3.resource('s3')
app = Application(s3, manifestPath, outputdir)
app.downloadLogs(outputdir)
except Exception as ex:
logging.exception("error in log downloader")
sys.exit(1)
def main():
parser = ArgumentParser(description=
'MegaMinerAI PyVis - Python Implementation of the Visualizer')
parser.add_argument('glog', type=str, nargs='*',
help='Optional glogs to open in the visualizer.')
parser.add_argument('-f', dest='fullscreen', action='store_true',
help='Start in fullscreen mode')
parser.add_argument('-a', dest='arena', metavar='server', type=str, nargs=1,
help='Enables arena mode querying from the given url')
parser.add_argument('-s', dest='spectate',
metavar=('server', 'gamenumber'), nargs=2, type=str,
help='Spectates on gamenumber at server.')
args = parser.parse_args()
app = Application(fullscreen=args.fullscreen)
'''
renderer = Renderer()
renderer.register_with_app(app)
app.request_update_on_draw(Test(renderer).update)
r = Renderer.Rectangle(1, 2, 20, 30, renderer=renderer)
try:
r = Renderer.Rectangle(40, 40, 20, 30)
except:
pass
'''
app.run(args.glog)
def main(args=None):
"""
The main routine
"""
app = Application()
app.run()
def test_detail_url(self):
self.print_header()
oracle = Application({
'host_name': 'test',
'name': 'test',
'type': 'generic',
})
url = MonitoringDetail({
'host_name': 'test',
'application_name': 'test',
'application_type': 'generic',
'monitoring_type': 'URL',
'monitoring_0': 'oracle://*****:*****@dbsrv:1522/svc',
})
oracle.monitoring_details.append(url)
oracle.resolve_monitoring_details()
self.assert_(len(oracle.urls) == 1)
# consol app_db_oracle class will call wemustrepeat() to create
# a fake LOGIN-detail, so there is a oracle.username
self.assert_(oracle.urls[0].username == 'dbadm')
self.assert_(oracle.urls[0].password == 'pass')
self.assert_(oracle.urls[0].hostname == 'dbsrv')
self.assert_(oracle.urls[0].port == 1522)
# will be without the / in the consol app_db_oracle class
self.assert_(oracle.urls[0].path == '/svc')
def test_not_a_dir(self):
conf = copy.copy(self.DUMMY_CONF)
conf['temp_dir'] = 'nonexistentdir'
with self.assertRaises(ConfigurationException):
app = Application(
BASE_DIR,
args_parser.parse_args([
'-c',
os.path.join('conf_files', 'dummy_file'), 'version'
]), conf)
conf = copy.copy(self.DUMMY_CONF)
conf['out_dir'] = 'nonexistentdir'
with self.assertRaises(ConfigurationException):
app = Application(
BASE_DIR,
args_parser.parse_args([
'-c',
os.path.join('conf_files', 'dummy_file'), 'version'
]), conf)
conf = copy.copy(self.DUMMY_CONF)
conf['log_dir'] = 'nonexistentdir'
with self.assertRaises(ConfigurationException):
app = Application(
BASE_DIR,
args_parser.parse_args([
'-c',
os.path.join('conf_files', 'dummy_file'), 'version'
]), conf)
def reload(self, reset=True):
'''
The reload function reloads the application and its reconstruction
This allows for updating the code while the GUI is active
This function does not reload the
:return:
'''
try:
self.disconnect()
import application
self.logger.warning("Reloading Application")
importlib.reload(application)
from application import Application
if reset:
# create a new empty application
self.app = Application(gui=self, logger=self.logger)
else:
# or create a copy of the existing application, but with functionality that is reloaded
self.app = Application.create_copy(application=self.app)
# add the new application for all widgets that use it
self.macro_photo_widget.set_app(self.app)
self.slice_photo_widget.set_app(self.app)
self.slice_table_widget.set_app(self.app)
self.coupe_table_widget.set_app(self.app)
# reconnect buttons:
self.connect()
# and update the gui
self.update()
except:
print(sys.exc_info()[0])
print(traceback.format_exc())
pass
def __init__(self, environ, app_cores, client_cores, nice=0, instance=1, size='train'):
Application.__init__(self, environ, 'Spec', client_cores, app_cores, nice, instance)
self._size = size
self._load_params = [self._bmark_name, self._size]
self._cleanup_params = [self._bmark_name]
self._run_params = [self._bmark_name, self._size, '0']
self._interfere_params = [self._bmark_name, self._size, '1']
def show_application(self, application, fullscreen, context):
"""
Render <application> widget with the given name and the given context.
"""
if isinstance(application, (str, unicode)):
tmp = self.theme.application.get(application)
if not tmp:
return log.error('no application named %s', application)
application = tmp(size=self.size, context=context)
self.add_layer(application, sibling=self.applications_idx)
elif application is None:
application = Application(self.size, [], context=context)
self.add_layer(application, sibling=self.applications_idx)
else:
application.visible = True
self.applications.remove(application)
# TODO: add show/hide/remove/unparent/whatever here
for l in self.layer:
l.visible = not fullscreen
if l == self.applications_idx:
break
if self.applications:
self.applications[-1].visible = False
self.applications.append(application)
return application
class MainApplication(tk.Tk):
"""Container for all frames within the application"""
def __init__(self, *args, **kwargs):
tk.Tk.__init__(self, *args, **kwargs)
# initialize menu
self.config(menu=MenuBar(self))
self.title("FIFA 16 Auto Buyer")
self.geometry("950x650-5+40")
self.minsize(width=650, height=450)
# bind ctrl+a
if platform == "darwin":
self.bind_class("Entry", "<Command-a>", self.selectall)
else:
self.bind_class("Entry", "<Control-a>", self.selectall)
self.status = StatusBar(self)
self.status.pack(side="bottom", fill="x")
self.status.set_credits("0")
self.appFrame = Application(self)
self.appFrame.pack(side="top", fill="both", expand="True")
def selectall(self, e):
e.widget.select_range(0, tk.END)
return "break"
class MainApplication(tk.Tk):
"""Container for all frames within the application"""
def __init__(self, *args, **kwargs):
tk.Tk.__init__(self, *args, **kwargs)
#initialize menu
self.config(menu=MenuBar(self))
self.title('FIFA 17 Auto Buyer')
self.geometry('950x650-5+40')
self.minsize(width=650, height=450)
# bind ctrl+a
if(platform == 'darwin'):
self.bind_class("Entry", "<Command-a>", self.selectall)
else:
self.bind_class("Entry", "<Control-a>", self.selectall)
self.status = StatusBar(self)
self.status.pack(side='bottom', fill='x')
self.status.set_credits('0')
self.appFrame = Application(self)
self.appFrame.pack(side='top', fill='both', expand='True')
def selectall(self, e):
e.widget.select_range(0, tk.END)
return 'break'
class MainApplication(tk.Tk):
"""Container for all frames within the application"""
def __init__(self, *args, **kwargs):
tk.Tk.__init__(self, *args, **kwargs)
#initialize menu
self.config(menu=MenuBar(self))
self.title('FIFA 16 Auto Buyer')
self.geometry('850x650-5+40')
self.minsize(width=650, height=450)
# bind ctrl+a
if(platform == 'darwin'):
self.bind_class("Entry", "<Command-a>", self.selectall)
else:
self.bind_class("Entry", "<Control-a>", self.selectall)
self.status = StatusBar(self)
self.status.pack(side='bottom', fill='x')
self.status.set_credits('0')
self.appFrame = Application(self)
self.appFrame.pack(side='top', fill='both', expand='True')
def selectall(self, e):
e.widget.select_range(0, tk.END)
return 'break'
def test_get_json_should_return_expected_json(self):
id = 66
name = "name"
available_version = "available_version"
download_location = "download_location"
relitive_install_path = "relitive_install_path"
executable_path = "executable_path"
installed_path = "installed_path"
icon = "icon"
current_version = "current_version"
shortcut_path = "shortcut_path"
app = Application(id, name, available_version, download_location,
relitive_install_path, executable_path,
installed_path, icon, current_version, shortcut_path)
expected_json = {
"id": 66,
"name": {
"en-us": "name",
},
"available_version": "available_version",
"download_location": "download_location",
"relitive_install_path": "relitive_install_path",
"executable_path": "executable_path",
"installed_path": "installed_path",
"icon": "icon",
"current_version": "current_version",
"shortcut_path": "shortcut_path",
}
actual = json.loads(app.get_json())
self.assertEquals(expected_json, actual)
def do_test_2():
"2nd Watsup Test"
filename = 'atestfile.txt'
if os.path.exists(filename):
os.remove(filename)
app = Application()
try:
app.connect_(title ='Simple Form')
except WindowNotFoundError:
app.start_(r'examples\simple.exe')
form = app.SimpleForm
form.Edit.SetText(filename)
sleep(.6)
print 'clicking button to create file'
form.CreateFile.Click()
# now check that the file is there
if os.path.exists(filename):
print 'file %s is present' % filename
else:
print "file %s isn't there" % filename
form.MenuSelect("File->Exit")
def main():
parse_command_line()
app = Application()
port = int(os.environ.get('PORT', 8888))
app.listen(port)
print('Run server on port: {}'.format(port))
tornado.ioloop.IOLoop.current().start()
class Main_Menu:
def __init__(self):
self.app = Application()
self.app.load()
self.options = {
"1.": self.app.sign_up,
"2.": self.app.sign_in,
}
def display_options(self):
print("""
************* MAIN MENU *************
Welcome to CheapFlights!
Please choose one of the options below:
1. Create an account
2. Sign in to your account
Q. Quit
""")
def run(self):
while True:
self.display_options()
option = input("Enter an option: ")
if option.lower() == "q":
print("JSON file has been saved to account.json file")
self.app.save()
break
action = self.options.get(option)
if action:
action()
else:
print("{0} is not a valid option, please try again!".format(option))
def __init__(self):
self.app = Application()
self.app.load()
self.options = {
"1.": self.app.sign_up,
"2.": self.app.sign_in,
}
def __init__(self, *args, **kwargs):
QtGui.QMainWindow.__init__(self, *args, **kwargs)
self._app = Application.instance()
title = "ChromaClub"
if self._app.isTestNet:
title += " [testnet]"
title += " - " + clubAsset['monikers'][0]
self.setWindowTitle(title)
self.setWindowIcon(QtGui.QIcon(':icons/chromaclub.png'))
self.resize(900, 550)
self.move(Application.instance().desktop().screen().rect().center() -
self.rect().center())
self.setCentralWidget(QtGui.QStackedWidget())
self.overviewpage = OverviewPage(self)
self.sendpage = SendPage(self)
self.chatpage = ChatPage(self)
self.centralWidget().addWidget(self.overviewpage)
self.centralWidget().addWidget(self.sendpage)
self.centralWidget().addWidget(self.chatpage)
self._create_actions()
self._create_menu_bar()
self._create_tool_bar()
self._create_status_bar()
self._create_tray_icon()
self._create_tray_icon_menu()
self._app.statusChanged.connect(self._status_changed)
def place_containers_with_group(self, app: Application, existing_group):
print("App {} requires {} containers".format(app, app.n_containers))
if existing_group == -1:
print("No preferred group to schedule with, check if can schedule on slot 1")
chosen_slot = JobGroupData.SLOT_1
if self.cluster.has_application_running():
print("There are already job running, scheduling on slot 2")
chosen_slot = JobGroupData.SLOT_2
app.cluster_slot = chosen_slot
for address,node in self.cluster.nodes.items():
if JobGroupData.cluster_slots_index[address] == chosen_slot:
self._place(app, node, 4)
else:
print("The chosen existing group to co-locate is: {}".format(existing_group))
co_located_app = None
running_apps, running_apps_weight = self.cluster.applications(with_full_nodes=False, by_name=True)
#print(running_apps.__str__())
for running_app in running_apps:
if JobGroupData.groupIndexes[running_app.name] == existing_group:
print("Choose app {} of group {} to co-locate".format(running_app.name, existing_group))
co_located_app = running_app
break
if co_located_app is not None:
print("The chosen slot to place new job is {}".format(co_located_app.cluster_slot))
app.cluster_slot = co_located_app.cluster_slot
for address, node in self.cluster.nodes.items():
#print(co_located_app.nodes)
#print(address)
if address in co_located_app.nodes:
self._place(app, node, 4)
def __init__(self, pkg, cfg):
Application.__init__(self, pkg, cfg)
self.type_id = u'codec'
self.requires_appdata = True
self.categories = []
self.cached_icon = False
self.icon = 'application-x-executable'
self.categories.append(u'Addons')
self.categories.append(u'Codecs')
# use the pkgname as the id
app_id = pkg.name
app_id = app_id.replace('gstreamer1-', '')
app_id = app_id.replace('gstreamer-', '')
app_id = app_id.replace('plugins-', '')
self.set_id('gstreamer-' + app_id)
# map the ID to a nice codec name
self.codec_name = {}
csvfile = open('../data/gstreamer-data.csv', 'r')
data = csv.reader(csvfile)
for row in data:
if row[1] == '-':
continue
codec_id = row[0][31:-3]
self.codec_name[codec_id] = row[1].split('|')
csvfile.close()
def test3(mocked_method):
app = Application()
# vytiskneme informaci o tom, zda se mockovaná metoda zavolala
print("mocked method called: {c}".format(c=mocked_method.called))
print("method1 returns: {v}".format(v=app.method1()))
# opět vytiskneme informaci o tom, zda se mockovaná metoda zavolala
print("mocked method called: {c}".format(c=mocked_method.called))
def main():
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s - %(filename)s[line:%(lineno)d] '
'- %(levelname)s: %(message)s',
filename='server.log')
game = Application([UserService, ChatService, GameService])
game.run()
def setUp(self):
self.generator = Generator()
self.generator.setup_logging()
self.hosts = {}
self.applications = {}
Application.init_classes([
os.path.join(os.path.dirname(__file__), '../recipes/default/classes'),
os.path.join(os.path.dirname(__file__), 'recipes/test10/classes')])
MonitoringDetail.init_classes([
os.path.join(os.path.dirname(__file__), '../recipes/default/classes'),
os.path.join(os.path.dirname(__file__), 'recipes/test10/classes')])
pass
row = ['drivelsrv', '11.120.9.10', 'Server', 'Red Hat 6.0', '', 'vs', '7x24', '2nd floor', 'ps']
final_row = { }
for (index, value) in enumerate(['host_name', 'address', 'type', 'os', 'hardware', 'virtual', 'notification_period', 'location', 'department']):
final_row[value] = [None if row[index] == "" else row[index]][0]
h = Host(final_row)
self.hosts[h.host_name] = h
row = ['drivel', 'mysql', '', '', '', 'drivelsrv', '7x24']
final_row = { }
for (index, value) in enumerate(['name', 'type', 'component', 'version', 'patchlevel', 'host_name', 'check_period']):
final_row[value] = [None if row[index] == "" else row[index]][0]
a = Application(final_row)
#a.__init__(final_row)
self.applications[a.fingerprint()] = a
setattr(a, "host", self.hosts[a.host_name])
def stop(self):
"""Stop the instance by pid. By the default
the signal is 15."""
Application.stop(self)
if socketStatus(self.hostname, self.port):
self._releaseOpenOfficePort()
self._cleanRequest()
def start(self):
"""Start Instance."""
self.path_user_installation = join(self.path_run_dir, \
"cloudooo_instance_%s" % self.port)
if exists(self.path_user_installation):
removeDirectory(self.path_user_installation)
# Create command with all parameters to start the instance
self.command = [join(self.office_binary_path, self._bin_soffice),
'-headless',
'-invisible',
'-nocrashreport',
'-nologo',
'-nodefault',
'-norestore',
'-nofirststartwizard',
'-accept=socket,host=%s,port=%d;urp;' % (self.hostname, self.port),
'-env:UserInstallation=file://%s' % self.path_user_installation,
'-language=%s' % self.default_language,
]
# To run soffice.bin, several environment variables should be set.
env = self.environment_dict.copy()
env.setdefault("LANG", "en_US.UTF-8")
env["HOME"] = self.path_user_installation
env["TMP"] = self.path_user_installation
env["TMPDIR"] = self.path_user_installation
self._startProcess(self.command, env)
self._cleanRequest()
Application.start(self)
def __init__(self, doc):
self.doc = doc
self.type = "" # this variable will be changed when we press any button regarding what type to
self.handler = ManageAccounts(doc)
self.handler.getData()
self.application = Application(self.handler.getAccounts())
def __init__(self, pkg, cfg):
Application.__init__(self, pkg, cfg)
self.type_id = 'inputmethod'
self.categories = [ 'Addons', 'InputSources' ]
self.icon = 'system-run-symbolic'
self.cached_icon = False
self.requires_appdata = True
def stop(self):
"""Stop the instance by pid. By the default
the signal is 15."""
Application.stop(self)
if socketStatus(self.hostname, self.port):
self._releaseOpenOfficePort()
self._cleanRequest()
def post_init():
app = Application()
init_result = app.init()
if not init_result:
reactor.stop()
return
app.app_logger.info("main loop ...")
def _process_files(mediafile, subtitlesfile): print "Processing the files now .." print "Media File --> " + mediafile print "Subtitles File -->" + subtitlesfile application = Application(mediafile, subtitlesfile) application.speech_recognition()
def show_application(self, application, fullscreen, context):
"""
Render <application> widget with the given name and the given context.
"""
if isinstance(application, (str, unicode)):
tmp = self.theme.application.get(application)
if not tmp:
return log.error('no application named %s', application)
application = tmp(size=self.size, context=context)
self.add_layer(application, sibling=self.applications_idx)
elif application is None:
application = Application(self.size, [], context=context)
self.add_layer(application, sibling=self.applications_idx)
else:
application.visible = True
self.applications.remove(application)
# TODO: add show/hide/remove/unparent/whatever here
for l in self.layer:
l.visible = not fullscreen
if l == self.applications_idx:
break
if self.applications:
self.applications[-1].visible = False
self.applications.append(application)
return application
def test_get_json_should_return_expected_json(self):
id = 66
name = "name"
available_version = "available_version"
download_location = "download_location"
relitive_install_path = "relitive_install_path"
executable_path = "executable_path"
installed_path = "installed_path"
icon = "icon"
current_version = "current_version"
shortcut_path = "shortcut_path"
app = Application(id, name, available_version, download_location, relitive_install_path, executable_path, installed_path, icon, current_version, shortcut_path)
expected_json = {
"id": 66,
"name": {
"en-us": "name",
},
"available_version": "available_version",
"download_location": "download_location",
"relitive_install_path": "relitive_install_path",
"executable_path": "executable_path",
"installed_path": "installed_path",
"icon": "icon",
"current_version": "current_version",
"shortcut_path": "shortcut_path",
}
actual = json.loads(app.get_json())
self.assertEquals(expected_json, actual)
def APPLY(next, n):
app = stack.pop()
args = [stack.pop() for x in range(n)]
#print app
#print args
#print app.arity, n
if isinstance(
app,
Application) and app.args is not None and len(app.args +
args) >= app.arity:
#print "apply type 1"
missing = app.arity - len(app.args)
app.args.extend(args[:missing])
apply = lookup(FakeFullyQualifId("", "_apply"))
#print args, missing, args[:missing], args[missing:]
for arg in args[missing:]:
app = Application(apply, [app, arg])
elif isinstance(app, Application):
#print "apply type 2"
app.args.extend(args)
elif not isinstance(app, Application) and app.arity < n:
#print "apply type 3"
app = Application(app, args[:app.arity])
apply = lookup(FakeFullyQualifId("", "_apply"))
for arg in args[app.arity:]:
app = Application(apply, [app, arg])
else:
#print "apply type 4"
app = Application(app, args)
stack.push(app)
return next
def main():
options.logging = None
parse_command_line()
options.subpath = options.subpath.strip('/')
if options.subpath:
options.subpath = '/' + options.subpath
# Connect to mongodb
io_loop = ioloop.IOLoop.instance()
# conn = torndb.Connection(config.DB_HOST + ":" + str(config.DB_PORT),
# config.DB_NAME, user = config.DB_USER, password = config.DB_PWD)
# self.conn = conn
# Star application
from application import Application
# app.conn=conn
if options.unix_socket:
server = tornado.httpserver.HTTPServer(Application())
socket = tornado.netutil.bind_unix_socket(options.unix_socket, 0o666)
server.add_socket(socket)
print('Server is running at %s' % options.unix_socket)
print('Quit the server with Control-C')
else:
http_server = tornado.httpserver.HTTPServer(Application())
http_server.listen(options.port)
print('Server is running at http://127.0.0.1:%s%s' %
(options.port, options.subpath))
print('Quit the server with Control-C')
io_loop.start()
def start(self, init=True):
"""Start Instance."""
self.path_user_installation = join(self.path_run_dir, \
"cloudooo_instance_%s" % self.port)
if init and exists(self.path_user_installation):
removeDirectory(self.path_user_installation)
# Create command with all parameters to start the instance
self.command = [join(self.office_binary_path, self._bin_soffice),
'-headless',
'-invisible',
'-nocrashreport',
'-nologo',
'-nodefault',
'-norestore',
'-nofirststartwizard',
'-accept=socket,host=%s,port=%d;urp;' % (self.hostname, self.port),
'-env:UserInstallation=file://%s' % self.path_user_installation,
'-language=%s' % self.default_language,
]
# To run soffice.bin, several environment variables should be set.
env = self.environment_dict.copy()
env.setdefault("LANG", "en_US.UTF-8")
env["HOME"] = self.path_user_installation
env["TMP"] = self.path_user_installation
env["TMPDIR"] = self.path_user_installation
self._startProcess(self.command, env)
self._cleanRequest()
Application.start(self)
def main2():
parser = argparse.ArgumentParser()
parser.add_argument(
"--date",
type=str,
help="The date used to load meetings from RMBS. Format: YYYY-MM-DD",
required=True)
parser.add_argument("--noMinWaste",
help="If set, then we will skip minWaste optimization",
action="store_true")
parser.add_argument("--debug", action="store_true")
parser.add_argument("--maxTime",
help="Max. resolving time in sec",
type=int,
default=600)
args = parser.parse_args()
_debug = args.debug
# We have 3 rooms (A, B and C)
# Use edge to mark which room is next to which
# g_rooms = networkx.Graph()
# for rm in list(room_names):
# g_rooms.add_node(rm)
# g_rooms.add_edge("A", "B")
# g_rooms.add_edge("B", "C")
rmbs = Rmbs()
applications = Application.get_applications(rmbs)
if not applications:
logger.info("No applications found")
return
df_apps = Application.applications_to_df(applications)
df_apps_too_late = df_apps.query(
f'status == "{Application.STATUS_TOO_LATE}"')
# Please note that each app form can apply for multiple days. Some may succeeed, and some may fail!
if len(df_apps_too_late) > 0:
logger.info(f"{len(df_apps_too_late)} found to be too_late")
Site.send_too_late_bookings_email(df_apps_too_late)
df_apps = df_apps.query(f'status != "{Application.STATUS_TOO_LATE}"')
if len(df_apps) == 0:
logger.info("No more non-too-late found")
return
grouped_apps = df_apps.groupby(['event_site', 'event_date'])
for group_name, df_entries in grouped_apps:
ret = process_site_applications(area=group_name[0],
rmbs=rmbs,
event_date=group_name[1],
requests=df_entries,
max_resolve_time=args.maxTime,
no_min_waste=args.noMinWaste)
Application.update_entries_status(df_entries, ret, rmbs)
def test3(mocked_method):
"""Použití handleru volaného namísto mockované funkce."""
app = Application()
# vytiskneme informaci o tom, zda se mockovaná metoda zavolala
print("mocked method called: {c}".format(c=mocked_method.called))
print("method1 returns: {v}".format(v=app.method1()))
# opět vytiskneme informaci o tom, zda se mockovaná metoda zavolala
print("mocked method called: {c}".format(c=mocked_method.called))
def main():
app = Application()
app.initialize()
for y in range(20):
for x in range(20):
app.cellManager.set_alive(x, y, True)
app.cellManager.next_generation()
app.window.quit()
def test2(mocked_method):
"""Druhý test zjištuje, zda se volala mockovaná metoda či nikoli."""
app = Application()
# vytiskneme informaci o tom, zda se mockovaná metoda zavolala
print("mocked method called: {c}".format(c=mocked_method.called))
print("method1 returns: {v}".format(v=app.method1()))
# opět vytiskneme informaci o tom, zda se mockovaná metoda zavolala
print("mocked method called: {c}".format(c=mocked_method.called))
def main(stdscr):
configs = Configs(host="localhost", port=1488, nport=1489)
# We must delay all our packages initialization to give native
# curses chance inialize inteslf properly.
from application import Application
app = Application(stdscr, configs)
app.run()
def init_class_cache(self):
Datasource.init_classes(self.classes_path)
logger.debug("init Datasource classes (%d)" % len(Datasource.class_factory))
Datarecipient.init_classes(self.classes_path)
logger.debug("init Datarecipient classes (%d)" % len(Datarecipient.class_factory))
Application.init_classes(self.classes_path)
logger.debug("init Application classes (%d)" % len(Application.class_factory))
MonitoringDetail.init_classes(self.classes_path)
logger.debug("init MonitoringDetail classes (%d)" % len(MonitoringDetail.class_factory))
def _get_app_node(self, network_node, app):
assert self._lock.locked()
name = "a%s" % app
if network_node.has_child(name):
return network_node.get_child(name)
# Obviously an app factory based on app id, someday...
application_node = Application()
application_node.configure({"parent": network_node, "name": name, "app": app})
application_node.start()
return application_node
def main():
app = Application()
renderer = Renderer()
renderer.register_with_app(app)
#app.request_update_on_draw(Test(renderer).update)
mainWindow = ui.Window(renderer, 50, 50, 300, 400)
mainWindow.addWidget(ui.Button, x=20, y=20, width=50, height=60, color=(1, 0, 1, 1), text="Example Text")
app.run()
def main(args):
projectDir = args[2]
outputDir = args[3]
print("Moving Assets")
app = Application(projectDir)
app.process(outputDir)
return 0
def main():
"main function"
root = Tk()
# set title
root.title("Visual Dictionary Tree")
app = Application(root)
app.mainloop()
def testAppSetup( self ):
self.assert_( Setting.is_app_setup() == False )
self.assert_( Application.has_been_setup() == False )
Setting(
app_name = 'Foobar',
app_version = 0.01,
allow_registration = True
).put()
self.assert_( Setting.is_app_setup() == True )
self.assert_( Application.has_been_setup() == True )
def initialize(self):
try:
web_config = self._get_web_config()
for web_app in web_config['applications']:
file_app = self._get_file_config(web_app['id'])
if file_app:
self._applications.append(Application.from_configs(web_app, file_app))
else:
self._applications.append(Application.from_configs(web_app))
except ConfigException as cfgex:
return (False, cfgex.error_code, cfgex.message)
return (True, "0", "Success")
def main():
app = Application()
renderer = Renderer()
renderer.register_with_app(app)
app.request_update_on_draw(Test(renderer).update)
r = Renderer.Rectangle(1, 2, 20, 30, renderer=renderer)
try:
r = Renderer.Rectangle(40, 40, 20, 30)
except:
pass
app.run()
def __init__(self, conf, options, output_prefix, init_equations=True, **kwargs):
"""`kwargs` are passed to ProblemDefinition.from_conf()
Command-line options have precedence over conf.options."""
Application.__init__(self, conf, options, output_prefix)
self.setup_options()
is_eqs = init_equations
if hasattr(options, "solve_not") and options.solve_not:
is_eqs = False
self.problem = ProblemDefinition.from_conf(conf, init_equations=is_eqs, **kwargs)
self.setup_output_info(self.problem, self.options)
def skencil_run(): """Skencil application launch routine.""" global config _pkgdir = __path__[0] config = get_app_config(_pkgdir) __path__.insert(0, os.path.join(_pkgdir, 'modules')) from application import Application app = Application(_pkgdir) app.run()
def sword_run(): """SWord application launch routine.""" global config _pkgdir = __path__[0] config = get_app_config(_pkgdir) os.environ["UBUNTU_MENUPROXY"] = "0" os.environ["LIBOVERLAY_SCROLLBAR"] = "0" from application import Application app = Application(_pkgdir) app.run()
def do_test_3():
"3rd Watsup Test"
app = Application()
try:
app.connect_(title ='Performance Form 2')
except WindowNotFoundError:
app.start_(r'examples\perform2.exe')
app.PerformanceForm1.Clickme.Click()
waited = 0
while not app.PerformacneForm1.Edit1._.Texts and not waited >= 1:
print 'waiting'
sleep(.1)
waited += .1
print `app.PerformacneForm1.Edit1._.Texts`
class Client:
def __init__(self, user):
self.user = user
self.ip = str(54) + '.' + str(random.randrange(0, 255)) + '.' + str(random.randrange(0, 255)) + '.' + str(random.randrange(0, 255))
self.connections = []
self.routerBuffer = []
self.inbox = {}
self.transportLayer = Transport(self)
self.applicationLayer = Application(self)
# Adds a link between this client and another
def addConnection(self, client):
if client == self:
return
if client.ip in self.connections:
return
self.connections.append(client.ip)
# Sends a message (tells the application layer to make a packet)
def sendMessage(self, source, destination, message , time):
applicationPacket = self.applicationLayer.generatePacket(time, source, destination, message)
tcpPackets = self.transportLayer.process(applicationPacket, time)
def __repr__(self):
return self.ip
def __str__(self):
return self.ip + ' - ' + str(self.connections) + " => Router Buffer: " + str(self.routerBuffer) + " Inbox: " + str(self.inbox)
def loadSettings(self, hostname, port, path_run_dir,
office_binary_path, uno_path, default_language,
environment_dict=None, **kw):
"""Method to load the configuratio to control one OpenOffice Instance
Keyword arguments:
office_path -- Full Path of the OOo executable.
e.g office_binary_path='/opt/openoffice.org3/program'
uno_path -- Full path of the Uno Library
"""
if environment_dict is None:
environment_dict = {}
Application.loadSettings(self, hostname, port, path_run_dir)
self.office_binary_path = office_binary_path
self.uno_path = uno_path
self.default_language = default_language
self.environment_dict = environment_dict
def __init__(self):
Application.__init__(self)
self.xorg_conf_path = "/etc/X11/xorg.conf"
self.xorg_conf_d_path = "/etc/X11/xorg.conf.d"
self.xorg_conf_backup_path = "%s-backup" %(self.xorg_conf_path)
self.xorg_conf_d_backup_path = "%s-backup" %(self.xorg_conf_d_path)
self.pages['welcome'] = self.create_welcome_page()
self.pages['actions'] = self.create_actions_page()
self.pages['reconfigure'] = self.create_reconfigure_page()
self.pages['troubleshoot'] = self.create_troubleshoot_page()
# Refresh
self.update_frame()
self.window.show_all()
self.on_page(None, 'welcome')
