def __init__(self, novel_helper, robot_army):
self.nh = novel_helper
self.novel_helper = novel_helper
self.book_warehouse = self.nh.book_warehouse
self.robot_army = robot_army
self.user_map = dict()
self.init_user_map()
self.book_map = dict()
self.init_book_map()
self.offline_uid_set = set(list(self.user_map.keys()))
self.recommend_uid_set = set()
self.choosing_uid_set = set()
self.click_drive_uid_set = set()
self.read_drive_uid_set = set()
self.reading_uid_set = set()
self.has_online_set = set()
self._period = 0
self.rec_sys = RecSysRandom(self)
self.event_manager = EventManager(self)
self.event_manager.clean_all_csv()
self.metrics_client = MetricsClient(self)
def _setup_event_system(self):
handlers = []
if self.config.logging and 'color' in self.config.logging and self.config.logging['color']:
handlers.append(ColoredLoggingHandler(self))
else:
handlers.append(LoggingHandler(self))
if self.config.enable_social:
handlers.append(SocialHandler(self))
if self.config.websocket_server_url:
if self.config.websocket_start_embedded_server:
self.sio_runner = SocketIoRunner(self.config.websocket_server_url)
self.sio_runner.start_listening_async()
websocket_handler = SocketIoHandler(
self,
self.config.websocket_server_url
)
handlers.append(websocket_handler)
if self.config.websocket_remote_control:
remote_control = WebsocketRemoteControl(self).start()
# @var EventManager
self.event_manager = EventManager(self.config.walker_limit_output, *handlers)
self._register_events()
if self.config.show_events:
self.event_manager.event_report()
sys.exit(1)
def __init__(self, root, is_type_editor):
"""
Args:
root: path of project root folder
is_type_editor: bool. see class docstring
"""
self.path = util.normpath(os.path.abspath(root))
self.is_type_editor = is_type_editor
self._auto_create_clazz_folder = True
# Must be the first
self.event_manager = EventManager()
self.type_manager = TypeManager()
self.fs_manager = FileSystemManager(
self, os.path.join(self.path, const.PROJECT_FOLDER_DATA))
# should after fs_manager
self.object_manager = ObjectManager(self)
# should after object_manager
self.ref_manager = RefManager()
# self._langauges = ('en', )
self._default_language = 'en'
self._translations = {}
self._verifier = None
self._loading_errors = AttrVerifyLogger()
self.tags = set()
self._next_ids = {} # {clazz_name: next_id}
self._loaded = False
self._editor_project = None
def _setup_event_system(self):
handlers = []
if self.config.logging_color:
handlers.append(ColoredLoggingHandler())
else:
handlers.append(LoggingHandler())
if self.config.websocket_server_url:
if self.config.websocket_start_embedded_server:
self.sio_runner = SocketIoRunner(
self.config.websocket_server_url)
self.sio_runner.start_listening_async()
websocket_handler = SocketIoHandler(
self, self.config.websocket_server_url)
handlers.append(websocket_handler)
if self.config.websocket_remote_control:
remote_control = WebsocketRemoteControl(self).start()
self.event_manager = EventManager(*handlers)
self._register_events()
if self.config.show_events:
self.event_manager.event_report()
sys.exit(1)
def on_handshake(event):
sock = event.get_initiator()
message = sock.recv(16)
connecting_session = uuid.UUID(bytes=message[:16])
storage = SimpleMemCache()
# Invalid Handshake
if len(message) != 16:
sock.send(Message('SERVER', 'Invalid handshake!').serialize())
sock.shutdown(SHUT_RDWR)
sock.close()
return
connecting_user = None
if connecting_session == uuid.UUID(int=0):
session_id = uuid.uuid4()
connecting_user = ConnectionUser(sock, session_id, random_name())
storage.add_user(connecting_user)
sock.send(Message('SERVER', '{}.{}'.format(session_id.int, connecting_user.name)).serialize())
elif storage.user_exists(connecting_session):
connecting_user = storage.get_user_by_id(connecting_session)
sock.send(Message('SERVER', '{}.{}'.format(connecting_session.int, connecting_user.name)).serialize())
EventManager().emit(RoomJoinEvent(event.get_room(), connecting_user))
def __init__(self, verbose=False, visual_debug=False):
self.verbose = verbose
self.visual_debug = visual_debug
ipdb.launch_ipdb_on_exception()
# Control Stuff
self.researched_warpgate = False # Remove me later
# Managers and controllers
self.worker_controller = WorkerController(bot=self,
verbose=self.verbose)
self.army_controller = ArmyController(bot=self, verbose=self.verbose)
self.scouting_controller = ScoutingController(bot=self,
verbose=self.verbose)
self.upgrades_controller = UpgradesController(bot=self,
verbose=self.verbose)
self.robotics_facility_controller = RoboticsFacilitiyController(
bot=self,
verbose=self.verbose,
)
self.gateway_controller = GatewayController(
bot=self, verbose=self.verbose, auto_morph_to_warpgate=True)
self.building_controller = BuildingController(bot=self,
verbose=self.verbose)
self.event_manager = EventManager()
self.build_order_controller = BuildOrderController(
verbose=self.verbose, bot=self)
self.coordinator = Coordinator(bot=self,
verbose=self.verbose,
build_order='three_gate_blink_all_in')
self.order_queue = []
def facade_main():
print("Client: I want to have a big party for my wife's birthday.\n")
em = EventManager()
em.arrange()
def main_setup(output_name):
'''
This should be called at the beginning of main if you're running unit tests
or simulations.
We need to set |globals_.event_manager| for most class definitions and helper
functions to make sense.
'''
globals_.event_manager = EventManager(output_name)
globals_.stats_manager = StatsManager(output_name)
def serve_one(self, sock):
EventManager().emit(HandshakingEvent(self, sock))
user = None
for u in self.connecting_users:
if u.get_socket() == sock:
user = u
while True:
message = sock.recv(1024)
if len(message) == 0:
EventManager().emit(RoomExitEvent(self, user))
break
else:
m = Message(raw=message)
if m.is_command():
EventManager().emit(
UserCommandEvent(self, user, Command(raw=message)))
else:
EventManager().emit(UserMessageEvent(self, user, m))
def test():
event_name = ["Fund", "Extreme"]
listener = [
Listener(event_name[0], start_fund),
Listener(event_name[1], start_extreme)
]
event_manager = EventManager()
event_manager.AddEventListener(listener[0])
event_driver = Event_Source(event_manager)
event_driver.start()
event_driver.start()
event_driver.start()
event_manager.Start()
def main():
parse_args()
ev = EventManager()
game = Game(ev, WIDTH, HEIGHT)
keybd = KeyboardController(ev)
movement_controller = MovementController(ev, game.sprites, game.board)
apply_fn(
lambda x: ev.register_listener(x),
[
keybd,
game,
movement_controller,
],
)
if IS_HOST:
begin_on_client_connect(ev, PORT)
else:
connect_to_server_host(ev, HOST, PORT)
reactor.run()
def main_setup():
random.seed(0)
globals_.event_manager = EventManager(None)
globals_.stats_manager = StatsManager('output')
from player import Player
from event_manager import EventManager
from db_connector import DbConnector
from data_listener import BookListener
initial_money = 10000
player_name = 'Notroop'
em = EventManager()
conn = DbConnector('postgres', 5432, 'postgres', '127.0.0.1')
file_path = 'D:\\genericbacktesters\\book_data\\file.dat'
bl = BookListener('', 12347, file_path)
player = Player(initial_money, player_name, em, conn)
symbol = 'YESBANK_EQ'
price = 1000
direction = 'SHORT'
quantity = 50
order_id = '9f04581c-a00b-4cd1-bb07-fd25ecf64315'
player.place_new_order(symbol, price, direction, quantity)
def register_events():
EventManager().register_handler(HandshakingEvent, on_handshake)
EventManager().register_handler(RoomJoinEvent, on_room_join)
EventManager().register_handler(UserMessageEvent, on_messaging)
EventManager().register_handler(RoomExitEvent, on_exit)
def runTest(self):
manager = EventManager(["./pkgs/"])
for i in xrange(30):
manager.notify()
from event_manager import EventManager manager = EventManager() manager.start()
def main():
# Config is a wrapper for a socket, and a channel (for now)
_config = config.Config(socketutils.connect_to_config(cf), cf.CHANNEL)
# This is to determine whether we log information or not
if cf.DO_LOG:
print("Doing logging.")
logging.set_logfile_func(cf.get_log_filename)
if not cf.DO_STDOUT:
logging.set_print_function(logging.no_print)
else:
print("Doing printing.")
log = logging.log
log_all = False
# API takes an object with socket and channel members
_api = ut.API(_config)
_manager = EventManager(_api)
# _manager.add_event(EveryLoopEvent(_callable=None, _api=_api, _manager=_manager, runs_till_event=30,
# extra_event=functools.partial(_api.send, "There have been 10 loops!")))
can_make_commanders = [
'dfolder'
] # This could be loaded from a configuration file & saved back to there
commanders = ['dfolder']
log('Starting bot. Information:\n\tSocket:', str(_api.socket),
'\n\tChannel:', _api.channel)
while True:
do_events(_api, _manager)
full_response = _api.resp()
_api.extend_resp_list(full_response)
while full_response is not None and len(full_response) > 0:
response = full_response.pop(0)
did_something = False
# We got a response from the server!
# First, let's clean it up if we're in full mode.
# This means that the response looks really ugly & includes a bunch of unnecessary information at the start.
if _api.full_mode:
try:
full_information = re.search(
r'^@badges=[\w/0-9,]*;color=[\w/0-9,]*;display-name=(\w*);.*?user-type=[\w/0-9,]* (.*)',
response)
log('[FULL RESPONSE]', full_information.strip('\r\n'))
except TypeError:
full_information = None
log("Got erroneous response: ")
log(str(response))
if full_information is not None:
log('[SENDER]', full_information.group(1))
response = full_information.group(2)
log('[RESPONSE]', response.strip('\r\n'))
command = re.search(
r':(\w*)!\1@\1\.tmi\.twitch\.tv PRIVMSG #\w* : *~(.+)$',
response)
if command is not None:
_command = command.group(2).strip('\r\n ')
_caller = command.group(1)
_args = None if len(_command.split(
' ', 1)) <= 1 else _command.split(' ', 1)[1]
_command = _command.split(' ')[0].lower()
if _caller in can_make_commanders:
if log_all:
log('[2] Executing command: ' + _command +
' with args: ' + str(_args))
if _command == 'conscript':
commanders.append(_args.lower())
did_something = True
elif _command == 'decommission':
commanders.remove(_args.lower())
did_something = True
if _caller in commanders:
# This should be improved later, but we're going to just check the command here
if log_all:
log('[1] Executing command: ' + _command +
' with args: ' + str(_args))
if _command == 'stop':
_manager.add_event_t(
SendMessageEvent,
message="Why don't you love me...",
after_run=functools.partial(
ut.safe_exit, _config, 0))
elif _command == 'print_full_debug':
log_all = True
log("Enabled full debugging mode.")
elif _command == 'no_full_debug':
log_all = False
elif _command == 'debug':
log("Attempting to print debug messages:")
log("Manager debug:")
log(_manager.dump_debug())
log("Command arguments:")
log(str(_args))
log("Current commanders:")
log(str(commanders))
# _manager.add_event_t(GetNoticesEvent)
elif _command == 'say' and _args is not None:
_manager.add_event_t(SendMessageEvent, message=_args)
elif _command == 'cap_req' and _args is not None:
_manager.add_event_t(SendCapReqEvent, message=_args)
elif _command == 'send_exact' or _command == 'say_exact' and _args is not None:
_manager.add_event_t(SendExactEvent, message=_args)
elif _command == 'enable_full':
_manager.add_event(
Event(_event=ut.enable_full,
_api=_api,
_manager=_manager))
elif _command == 'flush_log':
log("Flushing log.")
logging.flush()
elif not did_something:
# We didn't set moderator privileges and we don't have command use
if log_all:
log('The user ' + _caller + ' attempted to use ' +
_command + ' with args: ' + str(_args))
_manager.add_event_t(
SendMessageEvent,
message="Please stop trying to abuse me, " + _caller +
".")
# This is to avoid making Twitch angry
time.sleep(0.75)
