def check_import_mdl(self, path, s, states):
if states[IMPORT_STATE] != None:
keys = states.keys()
keys.sort()
for subs in keys:
if not subs in StateProperties:
print 'WARNING: Importation state has substate(s). This may cause unexpected error.'
break
filename = DynamicEvaluateExpression(states[IMPORT_STATE])
params = {}
keys = states[PARAMETERS].keys()
keys.sort()
for k in keys:
p = states[PARAMETERS][k]
b = DynamicEvaluateExpression(p[1])
params[k] = [p[0], b]
stnum = self.get_state_num(self.eventhandler.append_path(path, s))
if not self.compiled_files.has_key(filename):
eh = EventHandler(filename, None, params, 0, 0, [], [], 0,
None, self.eventhandler.options)
self.required_models.append(eh)
self.compiled_files[filename] = eh.options[MODEL_NAME]
self.submodels[stnum] = eh.options[MODEL_NAME]
else:
self.submodels[stnum] = self.compiled_files[filename]
def __init__(self, map_screen, background_screen, text_screen):
"""
Constructor.
:param map_screen: Surface
:param background_screen: Surface
:param text_screen: Surface
"""
self.amount_of_enemies = 0
self.amount_of_empty_colonies = 0
self.map_to_load = None
self.race_manager = RaceManager()
self.human_players = []
self.players = []
self.map = Map(GUISettings.SCREEN_WIDTH, GUISettings.SCREEN_HEIGHT)
self.event_handler = EventHandler(self)
self.screen = map_screen
self.background_screen = background_screen
self.player_one = Player()
self.human_players.append(self.player_one)
self.sound_driver = SoundDriver()
self.map_loader = MapLoader(self)
self.text_screen = text_screen
self.running = True
self.map_manager = MapManager()
self.state = MainMenu(self)
self.menu = MenuSettings.MAIN_MENU(self)
def __init__(self, device, grabbed=False):
self.dev = evdev.InputDevice(device)
self.eventHandler = EventHandler()
if grabbed:
self.dev.grab() #takes exclusive control over the keyboard
asyncio.get_event_loop().create_task(
self.keyboardHandler()) #starts the keyboad handler loop
def generate_java(canvas):
jname = canvas.statusbar.getState(StatusBar.MODEL)[1][0]
if not jname or jname == "Nonamed":
jname = tkFileDialog.asksaveasfilename(filetypes=[("Java source code",
"*.java")])
else:
if StringUtil.endswith(jname, ".py"):
jname = jname[:len(jname) - 3] + ".java"
jname = os.path.split(jname)[1]
jname = tkFileDialog.asksaveasfilename(initialfile=jname,
filetypes=[("Java source code",
"*.java")],
initialdir=canvas.codeGenDir)
if jname:
if StringUtil.endswith(jname, ".java"):
mname = jname[:len(jname) - 5] + ".des"
else:
mname = jname + ".java"
desc = generate_description(canvas, 0)["desc"]
eventhandler = EventHandler(mname, modeltext=desc)
g = JavaGenerator(eventhandler)
code = g.generate_code()
# Save .java file
jf = open(jname, "w")
jf.write(code)
jf.close()
# Print on success
print "Java code saved to: " + jname
def __init__(self, window, game):
self.window = window
self.game = game
self.screen = window.screen
self.state = GameState.MAIN_MENU
self.eventHandler = EventHandler(self.game)
self.objectHandler = ObjectHandler()
self.mapHandler = MapHandler(self.window)
self.loadMenu()
def __init__(self):
self.controller = Controller()
self.Handler = EventHandler(self.controller)
self.object_list = []
self.game_logic = GameLogic()
self.fps_clock = pygame.time.Clock()
self.fps = 60
self.neuralnet = NeuralNetHolder()
self.version = "v1.01"
def __init__(self):
self.graph = DAG.DAG()
self.MiscVals = {
'Name': '',
'PlayerName': '',
'Profession': '',
'Level': 0,
'Experience': 0
}
self.Events = EventHandler()
def _send_manual_notification(self, sessionKey, user, post_data):
logger.info("_send_manual_notification started", )
logger.debug("user: {}".format(user))
logger.debug("post_data: {}".format(post_data))
notification = {}
notifications = []
query = {}
query['incident_id'] = post_data.get('incident_id')
logger.debug("Filter: {}".format(json.dumps(query)))
uri = '/servicesNS/nobody/alert_manager/storage/collections/data/incidents?query={}'.format(
urllib.parse.quote(json.dumps(query)))
serverResponse, incident = rest.simpleRequest(uri,
sessionKey=sessionKey)
logger.debug("Settings for incident: {}".format(incident))
incidents = json.loads(incident)
notification['alert'] = incidents[0].get("alert")
notification['incident'] = post_data.get('incident_id')
notification['event'] = post_data.get('event')
notification_message = post_data.get('notification_message')
recipients = post_data.get('recipients')
recipients_overwrite = post_data.get('recipients_overwrite')
logger.debug("recipients_overwrite: {}".format(recipients_overwrite))
notifications.append(notification.copy())
ic = IncidentContext(sessionKey, notification['incident'])
context = ic.getContext()
context.update({'notification_message': notification_message})
context.update({'recipients': recipients})
context.update({'recipients_overwrite': recipients_overwrite})
logger.debug("Notification context: {}".format(json.dumps(context)))
eh = EventHandler(sessionKey=sessionKey)
eh.handleEvent(alert=notification['alert'],
event=notification['event'],
incident=incidents[0],
context=ic.getContext())
logger.info("_send_manual_notification stopped")
return self.response('Manual notification executed', http.client.OK)
def run(self, total_servers: int, total_arrival: int) -> None:
""" Begin the simulation of a MMCC system. Process the information until
termination criteria is meet.
Params:
- total_servers :: The number of servers that can handle clients at
any one instance.
- total_arrival :: The total number of clients that can be handled
within the simulation.
"""
# Initialise the beginning parameters of the simulation
self.servers = Servers(total_servers) # Set up server handler
self.events = EventHandler() # Set up the event handler
startingEvent = Event("arrival", 0) # Construct the first event object
startingEvent.departure_time -= startingEvent.arrival_time # Reset times
startingEvent.arrival_time = 0 # Reset times
self.events.add(startingEvent) # Create the first event
# Begin iteration of events, record arrivals for checking
self.num_arrival = 0
while (self.num_arrival < total_arrival):
# Collect next event from the event handler
currentEvent = self.events.next()
# Update simulation time
self.sim_time = currentEvent.time()
if currentEvent.type == "arrival":
# Arrival event received
self.num_arrival += 1 # Record number of arrivals
# Create new arrival event
self.events.add(Event("arrival", currentEvent.time()))
# Check if any server is available
if not self.servers.isFree():
self.events.block(
currentEvent) # Arriving client is blocked
continue
# Begin serving the client.
currentEvent.servedBy(self.servers.allocate())
# All event handler to manage departure
self.events.add(currentEvent)
else:
# Departure event received
self.servers.deallocate(
currentEvent.servedBy()) # Free the server
self.events.depart(currentEvent) # Record departure
def __init__(self, app):
super().__init__()
self.app = app
self.setupUi(self)
self.show()
self.current_dir = os.path.dirname(__file__)
self.current_mode = "Merge"
self.event_handler = EventHandler(self)
self.current_tool = Merger(self)
self.current_files = []
self.setupProgramm()
def __init__(self, screen):
self.screen = screen
self.bm = BlockManager()
self.im = ItemManager()
self.em = EffectManager()
self.mm = MobManager()
self.player = Player(self)
self.mobs = []
self.eh = EventHandler(self)
self.level = Level('ark.json', self.screen, self)
self.gui = None
pygame.mixer.music.load('assets/music/theme.mp3')
pygame.mixer.music.play(-1)
def _update_incident(self, sessionKey, user, post_data):
logger.debug("START _update_incident()")
required = ['incident_data']
missing = [r for r in required if r not in post_data]
if missing:
return self.response(
"Missing required arguments: {}".format(missing),
http.client.BAD_REQUEST)
incident_data = post_data.pop('incident_data')
splunk.setDefault('sessionKey', sessionKey)
eh = EventHandler(sessionKey=sessionKey)
config = {}
config['index'] = 'main'
restconfig = entity.getEntities('configs/alert_manager',
count=-1,
sessionKey=sessionKey)
if len(restconfig) > 0:
if 'index' in restconfig['settings']:
config['index'] = restconfig['settings']['index']
logger.debug("Global settings: {}".format(config))
# Parse the JSON
incident_data = json.loads(incident_data)
# Select between updating multiple incidents (replace full document) and updating single incidents (attribute update)
if 'incident_ids' in incident_data and len(
incident_data['incident_ids']) > 1:
logger.info("do_update_incidents")
self._do_update_incidents(sessionKey, config, eh, incident_data,
user)
elif 'incident_ids' in incident_data and len(
incident_data['incident_ids']) == 1:
logger.info("do_update_incident")
self._do_update_incident(sessionKey, config, eh,
incident_data['incident_ids'][0],
incident_data, user)
else:
logger.info("do_update_incident")
self._do_update_incident(sessionKey, config, eh,
incident_data['incident_id'],
incident_data, user)
return self.response('Successfully updated incident(s).',
http.client.OK)
def main_loop():
json_data = open("config.json").read()
config = json.loads(json_data)
bot = telegram.Bot(token=config["TOKEN_BOT"])
logging_user = config['logging_user'] if 'logging_user' in config.keys() else None
updater = Updater(bot=bot)
dispatcher = updater.dispatcher
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.DEBUG)
sender_filter = SenderFilterService(config)
message_sender = MessageSender(bot, config, logging_user=logging_user)
event_handler = EventHandler(sender_filter, message_sender, config, logging_user=logging_user)
all_handler = MessageHandler(Filters.all, event_handler.handle_all)
dispatcher.add_handler(all_handler)
print 'waiting new messages...'
updater.start_polling()
def __init__(self):
''' This function calls parents class, initialize infoWindow, load main window UI,
and call the clickOnDate function in eventHandler to get today's event list upon opening the GUI
Args:
none
Returns:
none
'''
self.eventHandler = EventHandler(self)
super(CalendarApp, self).__init__()
self.infoDialog = InfoWindow()
self.load_ui()
self.eventHandler.clickOnDate()
def __init__(self):
try:
self.graph = pickle.load(open(FILE_LOCATION, "rb"))
LoggerSingleton() # Initialise the logger when creating from binary file
except:
self.graph = generateDemoGraph()
self.builder = Gtk.Builder()
self.builder.add_from_file("MainScreen.glade")
self.builder.connect_signals(EventHandler(self.graph, self))
self.MainWindow = self.builder.get_object("MainWindow")
self.LoginWindow = self.builder.get_object("LoginWindow")
self.ConversionWindow = self.builder.get_object("ConversionWindow")
self.AdminWindow = self.builder.get_object("AdminWindow")
self.LoginWindow.show_all()
def run(self, server_number: int, arrival_total: int):
"""
Run simulation with specified parameters
:param server_number: Number of servers
:param arrival_total: Number of events
"""
# Initialise Servers and EventHandler
self.servers = Servers(server_number)
self.events = EventHandler()
# Create and add initial event
starting_event = Event("arrival", 0)
starting_event.departure_time -= starting_event.arrival_time
starting_event.arrival_time = 0
self.events.add(starting_event)
# Run simulation until number of events handled
self.arrival_number = 0
while (self.arrival_number < arrival_total):
# Iterate to next event and update simulation time
current_event = self.events.next()
self.simulation_time = current_event.time()
# If arrival, update counter and add to appropriate list
if current_event.event_type == "arrival":
self.arrival_number += 1
self.events.add(Event("arrival", current_event.time()))
# If no servers free, block event
if not self.servers.is_free():
self.events.block(current_event)
continue
# Assign server to event
current_event.served_by(self.servers.allocate())
self.events.add(current_event)
# If departure, free server and depart
else:
self.servers.deallocate(current_event.served_by())
self.events.depart(current_event)
def simulate(canvas):
global theCanvas
theCanvas = canvas
mname = canvas.statusbar.getState(StatusBar.MODEL)[1][0]
if not mname:
mname = "Nonamed.des"
else:
if mname.endswith(".py"):
mname = mname[:len(mname) - 3]
mname = mname + ".des"
global sc
sc = generate_description(canvas, 0)
global debugger
debugger = Debugger()
global eventhandler
eventhandler = EventHandler(mname,
callback=debugger.EventDebugger,
use_gui=1,
modeltext=sc["desc"])
eventhandler.final.append("SVMAToM3Plugin.finalize_simulation()")
debugger.CustomizeEvent(event_callback, None, 1)
global root
root = canvas.ASGroot.listNodes
DefaultInterpreter.runsource("eventhandler=SVMAToM3Plugin.eventhandler")
DefaultInterpreter.runsource("debugger=SVMAToM3Plugin.debugger")
debugger.SetEventHandler(eventhandler)
eventhandler.run_initializer()
highlight_states(eventhandler.state, sc)
highlight_trans(eventhandler, sc, root)
# Cannot start the Tk mainloop again
# eventhandler.run_interactor()
DefaultInterpreter.runsource(
"setup_gui_debugger(eventhandler, debugger, 0, 0)")
def add_event_handler(self, evh, uri_base):
type = evh.getAttribute('type')
file = evh.getAttribute("file")
code = ""
if file == "":
# if no file attribute is specified, it must
# be inline code
code = evh.childNodes[0].data
else:
# get the code from the specified file
if not re.match("(http:|\/|file:)", file):
# the uri appears to be relative, so we
# append it to the base uri
file = urlparse.urljoin(uri_base, file)
try:
code = "".join(urllib.urlopen(file).readlines())
except:
self.error("couldn't open file %s" % file)
code = code.replace("\r\n", "\n")
self.event_handlers[type] = EventHandler(self, type, code, file)
def __init__(self, window):
pygame.init()
self.window = window
self.event_handler = EventHandler()
self.renderer = Renderer(window)
self.data = Data(10, 300, 64)
self.buttons = [
RandomizeButton(BLACK, 25, 25, 125, 25, 'Randomize Data', WHITE,
self.data),
SorterButton(BLACK, 175, 25, 125, 25, 'Bubble Sort', WHITE,
BubbleSorter(self.renderer), self.data),
SorterButton(BLACK, 325, 25, 125, 25, 'Selection Sort', WHITE,
SelectionSorter(self.renderer), self.data),
SorterButton(BLACK, 475, 25, 125, 25, 'Insertion Sort', WHITE,
InsertionSorter(self.renderer), self.data),
SorterButton(BLACK, 625, 25, 125, 25, 'Merge Sort', WHITE,
MergeSorter(self.renderer), self.data),
SorterButton(BLACK, 775, 25, 125, 25, 'Quick Sort', WHITE,
QuickSorter(self.renderer), self.data)
]
self.event_handler.register_buttons(self.buttons)
self.renderer.register_buttons(self.buttons)
self.renderer.register_data(self.data)
parser = argparse.ArgumentParser('Settings for Morris Bot')
parser.add_argument('-T',
'--token',
help='Token which you got from your group admin.')
parser.add_argument(
'-Pl',
'--parser-login',
help=
'Login for your bot-account. Opens new feature like a parsing timetable')
parser.add_argument('-Pp',
'--parser-password',
help='Password for your bot-account.')
args = vars(parser.parse_args())
bot = EventHandler()
token = args.get('token')
# Creating group-class
group = Group()
group.auth(token)
group.connect_storage(DBProxy(Member))
bot.set_group(group)
# Setup account for bot. This is need for parsing group wall and timetable
account = BotAccount.get_account()
account.auth(args.get('parser-login'), args.get('parser-password'))
# Setup observers that handle commands
command_observer = IObserver.get_observer(CommandObserver)
params = {}
while argn < len(sys.argv):
arg = sys.argv[argn]
argn = argn + 1
param = ParseOption(arg)
if param != None:
par = ParseParameter(param[0])
params[par[0]] = [par[1], param[1]]
if command_only:
if len(name) > 4 and string.upper(name[len(name) - 4:]) == ".DES":
model_name = name[:len(name) - 4]
else:
model_name = name
else:
eventhandler = EventHandler(name, None, params, use_gui, 1,
haddition, taddition, 0)
model_name = eventhandler.options[MODEL_NAME]
code_type = string.lower(code_type)
info = {"time": None, "compile": None, "run": None, "file": None}
desc = [[], ["time", "Time spent on compilation: "],
["file", "File(s) generated: "], [],
["compile", "Command to compile the source: "],
["run", "Command to run the compiled code: "], []]
starttime = time.time()
if code_type == "java":
if not command_only:
from JavaGenerator import JavaGenerator
g = JavaGenerator(eventhandler)
g.generate()
from IoTPlatform import IoTPlatform
from EventHandler import EventHandler
# Args
parser = argparse.ArgumentParser(description='Process some integers.')
parser.add_argument('--ip', default='127.0.0.1', action='store', type=str, help='ipaddres to connect')
args = parser.parse_args()
IPAddress = args.ip
logging.basicConfig(level=logging.INFO)
logging.info("StartCreate")
# Creating Custom Classes
iotPlatform = IoTPlatform(IPAddress)
eventHandler = EventHandler()
class ThreadingSimpleServer(ThreadingMixIn, HTTPServer):
pass
class HTTPServer_RequestHandler(BaseHTTPRequestHandler):
def do_POST(self):
self.send_response(200)
# change to one origin
self.send_header('Access-Control-Allow-Origin', '*')
self.end_headers()
content_length = int(self.headers['Content-Length']) # <--- Gets the size of data
post_data = self.rfile.read(content_length) # <--- Gets the data itself
command, splittedMsg = self.extractObjFromMessage(post_data)
def setup_signal(self):
handler = EventHandler()
self.searchButton.clicked.connect(
lambda: handler.search_button_onclicked(self.searchLineEdit.text(),
self.searchTableView))
if __name__ == '__main__':
#init config file
print "load global config file"
if len(sys.argv) < 2:
config.load("../conf/mymeego.conf")
else:
config.load(sys.argv[1])
#init mainloop
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
# get session bus
bus = dbus.SessionBus()
mainloop = gobject.MainLoop()
event_handler = EventHandler(mainloop)
# init upnp ########
configfile = config.coherence_conf
if len(configfile) <= 0:
sys.exit("no coherence config file specified in config or else")
upnp = BackendUpnp(event_handler, configfile, config.device_name,
config.device_type)
# end upnp init ####
# init closing signals
signal.signal(signal.SIGINT, close) # CTRL+C signal error
signal.signal(signal.SIGQUIT, close) # terminal quit
# init modules
dbus_module = DbusModule(event_handler, "dbus", "org.mymeego.Ui",
.format(search_name, config['title'], payload.get('app'),
result_count))
# Get saved search config
savedSearch = getSavedSearch(payload.get('app'), search_name,
sessionKey)
log.debug(
"Parsed savedsearch settings: expiry={} digest_mode={}".format(
savedSearch['content']['alert.expires'],
savedSearch['content']['alert.digest_mode']))
# Parse ttl
ttl = getTTL(savedSearch['content']['alert.expires'])
# Get helpers
eh = EventHandler(sessionKey=sessionKey)
sh = SuppressionHelper(sessionKey=sessionKey)
incident_id = None
incident_key = None
# If append_incident is set, look for an existing incident_id
log.debug("Append Incident: {}".format(config['append_incident']))
if config['append_incident']:
incident_key, incident_id = getIncidentIdByTitle(
config['title'], sessionKey)
# Create unique id
if incident_id is None:
incident_id = str(uuid.uuid4())
token = util.prompt_for_user_token('espo1234', 'user-library-read user-read-playback-state', client_id=credentials['CLIENT_ID'], client_secret=credentials['CLIENT_SECRET'],redirect_uri='http://localhost:8888/callback')
settings = {
'showLyrics': True
}
def booleanify(string):
return string == 'true' or string == 'on' or string == '1'
def onNextTrack():
currently_playing = sp.currently_playing()
if currently_playing == None:
print('None playing')
else:
print(PyLyrics.getLyrics(currently_playing['item']['artists'][0]['name'], currently_playing['item']['name']))
def onCommand(args):
command = args[0]
if command == 'lyrics':
settings['showLyrics'] = booleanify(args[1])
if token:
print('token is good!')
sp = spotipy.Spotify(auth=token)
test = EventHandler(sp, onNextTrack, onCommand)
else:
raise Exception("Can't get token for " + username)
def add_new_event_handler(self, type, code):
self.event_handlers[type] = EventHandler(self, type, code)
def threadFunc(base_path, file_name):
EventHandler(base_path, file_name, upload_file)
#! /usr/bin/env python3
import sys
sys.path.append(",")
from pathlib import Path
from time import sleep
from watchdog.observers import Observer
from EventHandler import EventHandler
if __name__ == '__main__':
watch_path = Path.home() / 'C:/Users/mwiniarski/Downloads/cleaner'
destination_root = Path.home(
) / 'C:/Users/mwiniarski/Downloads/cleaner/holder of things'
event_handler = EventHandler(watch_path=watch_path,
destination_root=destination_root)
observer = Observer()
observer.schedule(event_handler, f'{watch_path}', recursive=True)
observer.start()
try:
while True:
sleep(60)
except KeyboardInterrupt:
observer.stop()
observer.join()
from JumpScale import j from EventHandler import EventHandler from ErrorConditionHandler import ErrorConditionHandler j.errorconditionhandler = ErrorConditionHandler() j.events = EventHandler()
