def path_find(self, x, y):
"""
"A-star" is probably a cloth brand from some US rap singer...
Let's do our own stupid greedy, short-sighted algo instead, right?
"""
if self.x == x and self.y == y:
return Action(ActionType.STOP)
direction = None
if self.y > y:
if not self.blocked(self.x, self.y - 1):
direction = Direction.NORTH
elif self.y < y:
if not self.blocked(self.x, self.y + 1):
direction = Direction.SOUTH
if direction is None and self.x > x:
if not self.blocked(self.x - 1, self.y):
direction = Direction.WEST
elif direction is None and self.x < x:
if not self.blocked(self.x + 1, self.y):
direction = Direction.EAST
if direction is not None:
return Action(ActionType.MOVE, direction)
else:
self.random_steps = 10
self.random_action = RandomPolicy().action(self.team_id,
self.observation)
return self.random_action
def work():
if not client_status.is_actual_version():
check_update()
actions.clear()
if client_status.last_fs_upload:
nxt = client_status.last_fs_upload + timedelta(seconds=FS_SET_PERIOD)
till_next = max(0, total_seconds(nxt - datetime.utcnow()))
del nxt
else:
till_next = 0
actions.add(Action(24 * HOUR, check_system_info, start=2 * MIN))
actions.add(StepAction(FS_SET_PERIOD, update_fs, start=till_next))
actions.extend([
Action(LOG_UPLOAD_PERIOD, upload_log),
Action(CHANGES_CHECK_PERIOD, check_changes)
])
if config.database or client_status.database:
actions.add(Action(DB_CHECK_PERIOD, check_db, start=7 * MIN))
if client_status.amazon:
actions.add(Action(backup.next_date, make_backup))
else:
actions.add(
OneTimeAction(
5 * MIN,
get_s3_access,
followers=[ActionSeed(backup.next_date, make_backup)]))
if os.path.exists(CRASH_PATH) and os.stat(CRASH_PATH).st_size > 0:
actions.add(OneTimeAction(10 * MIN, report_crash, start=0))
try:
log.info('Action pool is:\n%s' % '\n'.join([str(a) for a in actions]))
except TypeError:
msg = ['Failed to iterate actions.']
if isinstance(actions, ActionPool):
msg.append('ActionPool object has %s__iter__ method.')
msg[-1] %= '' if hasattr(actions, '__iter__') else 'no '
if hasattr(actions, '_actions'):
if isinstance(actions._actions, list):
if actions._actions:
f = ', '.join((a.__name__ for a in actions._funcs()))
msg.append('There are functions: %s.' % f)
else:
msg.append('_actions is empty list.')
else:
msg.append('_actions is %s.' % type(actions._actions))
else:
msg.append('There is no _actions in actions.')
else:
msg.append('Type of actions is %s' % type(actions))
log.error(' '.join(msg))
log.info('Start main loop')
while True:
action = actions.next()
log.info('Next action is %s' % action)
time.sleep(action.time_left())
action()
def __init__(self):
self.isEnabled = True
self.openInven = Action(0, self.openInventory)
self.feedBeer = Action(0, self.feedBeerToWorkers)
self.last_frame = None
self.state = State.BASE
def update(self, agent_update):
observation_map = agent_update.observation_map
observation = observation_map.observations[self.agent_id]
self.position = (
observation.get_value(self.feature_names['x']).feature_value,
observation.get_value(self.feature_names['y']).feature_value,
)
observed_bases = {}
for direction, basis in zip(self.direction_bases.keys(), self.direction_bases.values()):
distance = observation.get_value(self.feature_names[direction]).feature_value
observed_bases[basis] = distance
"""
if self.updates < 5:
print "agent position: " + str(self.position)
print "bases: " + str(observed_bases)
self.updates += 1
"""
self.log_map, self.observed_map = self.update_maps(
self.position,
self.log_map,
self.observed_map,
observed_bases,
)
action_map = ActionMap()
action = Action()
next_x, next_y = self.next_movement(self.position, self.log_map)
x_component = NumericActionComponent(next_x)
action.add_component(self.component_names['x'], x_component)
y_component = NumericActionComponent(next_y)
action.add_component(self.component_names['y'], y_component)
action_map.add_action(self.agent_id, action)
return action_map
def __init__(self, log, conf=None):
Action.__init__(self, log, conf)
self.log = log
self.records = []
self.sources = {}
self.debug_records_sent = []
if conf:
for c in conf:
self.add_source(c)
def new_message():
message_complete_data = json.loads(request.data)
print(message_complete_data)
try:
action = Action(bot_name, telegram_uri, message_complete_data)
action.evaluate()
return 'Action has been executed'
except:
return 'Error excecuting action'
def handle_keys_choose_option(key):
action: [Action, None] = None
index = key - 97
if index >= 0:
return Action(ActionType.CHOOSE_OPTION, option_index=index)
elif key == tcod.event.K_TAB or key == tcod.event.K_ESCAPE:
return Action(ActionType.TOGGLE_INVENTORY)
return action
def handle_keys_main_menu(key):
action: [Action, None] = None
if key == tcod.event.K_a:
action = Action(ActionType.NEW_GAME)
elif key == tcod.event.K_b:
action = Action(ActionType.LOAD_GAME)
elif key in (tcod.event.K_c, tcod.event.K_ESCAPE):
action = Action(ActionType.ESCAPE)
return action
def handle_keys_targeting(key):
action: [Action, None] = None
action = handle_movement_keys(key)
if action is None:
if key == tcod.event.K_ESCAPE:
action = Action(ActionType.ESCAPE)
elif key in (tcod.event.K_KP_ENTER, tcod.event.K_SPACE):
action = Action(ActionType.EXECUTE)
return action
def handle_keys_player_turn(key) -> [Action, None]:
action: [Action, None] = None
if key == tcod.event.K_g:
action = Action(ActionType.GRAB)
elif key == tcod.event.K_a:
action = Action(ActionType.TOGGLE_INVENTORY)
elif key == tcod.event.K_d:
action = Action(ActionType.DROP_INVENTORY_ITEM)
elif key == tcod.event.K_PERIOD:
action = Action(ActionType.WAIT)
elif key == tcod.event.K_SPACE:
action = Action(ActionType.INTERACT)
elif key == tcod.event.K_e:
action = Action(ActionType.LOOK)
elif key == tcod.event.K_ESCAPE:
action = Action(ActionType.ESCAPE)
elif key == tcod.event.K_r:
action = Action(ActionType.SWAP_APPENDAGE)
elif action is None:
action = handle_movement_keys(key)
# No valid key was pressed
return action
def __init__(self, rule_context, rule_state, data, nested_rule):
"""
@type rule_state: RuleState
@type rule_context: RuleContext
@type data: matplotlib.pyparsing.ParseResults
@type nested_rule: Rule
@type parent_rule: Rule
"""
self.nested_rule = nested_rule
self.parent = None
if self.nested_rule is None:
self.actions = [
Action(action, 'always_fire_actions' in data)
for action in data['actions']
]
else:
self.actions = []
self.nested_rule.set_parent(self)
self.override = "override" in data
self.overrideOff = False
if self.override and len(data["override"]) == 1:
warning = "rule '%s' has override configuration and will turn a possible override state off"
self.overrideOff = True
__logger__.info(warning % rule_state.rule_name)
elif self.override:
__logger__.info(
"rule '%s' has override configuration and will turn a possible override state on"
% rule_state.rule_name)
self.rule_state = rule_state
self.rule_context = rule_context
self.always_fire = False
def load_actions(self, table, table_name):
built_actions = {}
for item in table.all():
new_object = Action.get_action(self, table, item.eid, item,
table_name)
built_actions[item.eid] = new_object
return built_actions
def __init__(self, **enemy):
self.name = enemy['name']
self.size = enemy['size']
self.type = enemy['type']
self.alignment = enemy['alignment']
self.AC = enemy['ac']
self.armorType = enemy['armorType']
self.hp = enemy['hp']
self.STR = enemy['STR']
self.DEX = enemy['DEX']
self.CON = enemy['CON']
self.INT = enemy['INT']
self.WIS = enemy['WIS']
self.CHA = enemy['CHA']
self.initiative = enemy['initiative']
self.alive = True
self.currentstatus = 'Healthy'
self.actions = [Action(**i) for i in enemy['actions']]
self.max = enemy['maxhp']
self.enemyId = enemy['enemyId']
self.combatId = enemy['combatId']
self.savingThrows = enemy.get('savingThrows', None)
self.challenge = enemy['challenge']
self.languages = enemy['languages']
self.senses = enemy['senses']
self.bloodied = enemy['bloodied']
self.damage_vulnerabilities = enemy['damage_vulnerabilities']
self.damage_resistances = enemy['damage_resistances']
self.damage_immunities = enemy['damage_immunities']
self.condition_immunities = enemy['condition_immunities']
if enemy.get('specialTraits', None):
self.specialTraits = [
SpecialTraits(**i) for i in enemy['specialTraits']
]
self.actionsText = [ActionsText(**i) for i in enemy['actionsText']]
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.RawTextHelpFormatter)
parser.add_argument('--credentials', type=existing_file,
metavar='OAUTH2_CREDENTIALS_FILE',
default=os.path.join(
os.path.expanduser('/home/pi/.config'),
'google-oauthlib-tool',
'credentials.json'
),
help='Path to store and read OAuth2 credentials')
args = parser.parse_args()
with open(args.credentials, 'r') as f:
credentials = google.oauth2.credentials.Credentials(token=None,
**json.load(f))
with Assistant(credentials) as assistant:
subprocess.Popen(["aplay", "/home/pi/GassistPi/sample-audio-files/Startup.wav"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
for event in assistant.start():
process_event(event)
usrcmd=event.args
if 'trigger'.lower() in str(usrcmd).lower():
assistant.stop_conversation()
Action(str(usrcmd).lower())
if 'play'.lower() in str(usrcmd).lower():
assistant.stop_conversation()
YouTube(str(usrcmd).lower())
if 'stop'.lower() in str(usrcmd).lower():
stop()
def handle_keys(key) -> [Action, None]:
action: [Action, None] = None
if key == tcod.event.K_UP:
action = Action(ActionType.MOVEMENT, dx=0, dy=-1)
elif key == tcod.event.K_DOWN:
action = Action(ActionType.MOVEMENT, dx=0, dy=1)
elif key == tcod.event.K_LEFT:
action = Action(ActionType.MOVEMENT, dx=-1, dy=0)
elif key == tcod.event.K_RIGHT:
action = Action(ActionType.MOVEMENT, dx=1, dy=0)
elif key == tcod.event.K_ESCAPE:
action = Action(ActionType.ESCAPE)
# No valid key was pressed
return action
def set_context(received_context):
global context
context = received_context
context.register_action(
Action("screenshot",
take_screenshot,
menu_name="Take screenshot",
description="Takes a screenshot from previous app"))
def add_action(self, textMessage):
cmd = extract_verb(textMessage.lower())
print(cmd)
args = textMessage.replace(cmd, '')
runner = None
if cmd == "fala":
runner = TalkRunner()
action = Action(runner, args)
self.actions.append(action)
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.RawTextHelpFormatter)
parser.add_argument('--credentials', type=existing_file,
metavar='OAUTH2_CREDENTIALS_FILE',
default=os.path.join(
os.path.expanduser('~/.config'),
'google-oauthlib-tool',
'credentials.json'
),
help='Path to store and read OAuth2 credentials')
parser.add_argument('--device_model_id', type=str,
metavar='DEVICE_MODEL_ID', required=True,
help='The device model ID registered with Google.')
parser.add_argument('--project_id', type=str,
metavar='PROJECT_ID', required=False,
help='The project ID used to register device '
+ 'instances.')
args = parser.parse_args()
with open(args.credentials, 'r') as f:
credentials = google.oauth2.credentials.Credentials(token=None,
**json.load(f))
with Assistant(credentials, args.device_model_id) as assistant:
subprocess.Popen(["aplay", "/home/pi/GassistPi/sample-audio-files/Startup.wav"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
events = assistant.start()
print('device_model_id:', args.device_model_id + '\n' +
'device_id:', assistant.device_id + '\n')
if args.project_id:
register_device(args.project_id, credentials,
args.device_model_id, assistant.device_id)
for event in events:
process_event(event, assistant.device_id)
usrcmd=event.args
if 'trigger'.lower() in str(usrcmd).lower():
assistant.stop_conversation()
Action(str(usrcmd).lower())
if 'stream'.lower() in str(usrcmd).lower():
assistant.stop_conversation()
YouTube(str(usrcmd).lower())
if 'stop'.lower() in str(usrcmd).lower():
stop()
if 'tune into'.lower() in str(usrcmd).lower():
assistant.stop_conversation()
radio(str(usrcmd).lower())
if 'wireless'.lower() in str(usrcmd).lower():
assistant.stop_conversation()
ESP(str(usrcmd).lower())
if 'parcel'.lower() in str(usrcmd).lower():
assistant.stop_conversation()
track()
if 'news'.lower() in str(usrcmd).lower() or 'feed'.lower() in str(usrcmd).lower() or 'quote'.lower() in str(usrcmd).lower():
assistant.stop_conversation()
feed(str(usrcmd).lower())
if 'on kodi'.lower() in str(usrcmd).lower():
assistant.stop_conversation()
kodiactions(str(usrcmd).lower())
def _valid_actions(self):
valid_actions = []
for act in Action.__members__.values():
lines = self._get_lines(action=act.get_value())
if self._game_board.movable(lines=lines,
to_left=Action.left_direction(
act.get_value())):
valid_actions.append(act.get_value())
return valid_actions
def get_stacked_action(self, stacked_state):
"""Given the current (stacked) game state, determine what action the model will output"""
# take a random action epsilon fraction of the time
if random.random() < self.epsilon:
return get_random_action()
# otherwise, take the action which maximizes expected reward
else:
q_values = self.net(
torch.FloatTensor(stacked_state).to(self.device))
action_idx = torch.argmax(q_values).item()
return Action(action_idx)
def do_action(self, action: actions.Action,
pos: base.Vec2d) -> actions.Action:
if self.modules[pos.x][pos.y].active:
self.active_modules.remove((pos.x, pos.y))
self.modules[pos.x][pos.y] = action.do(self.modules[pos.x][pos.y], pos)
if self.modules[pos.x][pos.y].active:
self.active_modules.add((pos.x, pos.y))
return action
def play_guard(self, player: int, target: int, guess: Cards) -> Action:
print('player: {0}, target: {1}, guess: {2}'.format(
player, target, guess))
if (target == -1):
raise IllegalActionException('Target myst be specified')
if (player == target):
raise IllegalActionException('Player cannot target themself')
if (guess == None):
raise IllegalActionException('Player must guess a card')
if (guess == Cards.GUARD):
raise IllegalActionException('Player cannot guess a guard')
return Action(Cards.GUARD, player, target, guess)
def __init__(self, type_):
f = open(os.path.join("data/enemy_data.json"), "r")
data = json.load(f)
if type_ not in data.keys():
raise Exception("Sorry, no enemies availible")
self.enemy = data[type_]
self.type = type_
self.actions = []
#Damage list of two ints, damage will RANGE from the first & second. EX. CSE220 dmg ranges from 5 to 12
self.damage = self.enemy["damage"]
self.hp = 100
for action in self.enemy["actions"]:
self.actions.append(Action(action))
def get_action(self, state):
"""Used when playing the actual game"""
if random.random() < self.end_epsilon:
return get_random_action()
else:
pp_state = self.preprocess_state(state)
self.state_buffer.append(pp_state)
stacked_state = np.stack([self.state_buffer])
q_vals = self.net(
torch.FloatTensor(stacked_state).to(self.device)).to(
self.device)
action_idx = torch.argmax(q_vals).item()
return Action(action_idx)
def __init__(self):
self.isEnabled = False
self.reelInFishAction = Action(0, self.reelInFish)
self.castLineAction = Action(0, self.castLine)
self.classifier = Classifier('./ml/')
self.comp_img = cv.imread('resources/fishing_space_bar.jpg', 0)
self.window = GameWindow("BLACK DESERT")
self.colorGrabber = ColorGrabber()
self.outputColors = False
self.outputKeys = False
self.swapRods = False
self.rodCharSeq = ''
self.rodSwapThresh = 5
self.collectAll = True
self.discardBlue = False
self.discardGreen = False
self.collectUnknowns = False
self.reset()
def deserialize(cls, state, logger):
game = cls(logger)
game.game_id = state['id']
game.num_players = state['numPlayers']
for player in state['players']:
game.players.append(Player.deserialize(player, logger))
for action in state['actions']:
game.actions.append(Action.deserialize(action, logger))
game.harvests = state['harvests']
game.turn = state['turn']
game.starting_player_idx = state['startingPlayerIdx']
game.active_player_idx = state['activePlayerIdx']
game.phase = state['phase']
return game
def action(self, team_id, observation):
"""
Chose an action at random, with a bias towards moving
"""
action_types = [item for item in ActionType]
directions = [item for item in Direction]
action_type = random.choices(action_types, weights=[10, 100, 1])[0]
if action_type == ActionType.MOVE:
direction = random.choices(directions)[0]
else:
direction = None
action = Action(action_type, direction)
return action
def do_action(self, action):
"""
First, extract lines according to user's input, within each line holds the coordinate of each tile
Then, move and merge tiles
:param action:
:return:
"""
lines = self._get_lines(action=action)
self._game_board.merge_tile(
lines=lines, merge_to_left=Action.left_direction(action))
self._move_count += 1
self._weighted_score = float(self._game_board.get_score()) / float(
self._move_count)
def action(self, team_id, observation):
if self.random_steps > 0: # super smart way of avoiding to get stuck ;)
self.random_steps -= 1
return self.random_action
self.parse(observation, team_id)
if self.resources > 0 or self.health <= 2:
# return to base
_, target_x, target_y = self.find_item("BASE")
else:
# find some resource
resource, target_x, target_y = self.find_item("RESOURCE")
if resource is None:
return Action(ActionType.STOP)
return self.path_find(target_x, target_y)
def handle_movement_keys(key):
action: [Action, None] = None
if key == tcod.event.K_u:
action = Action(ActionType.MOVEMENT, dx=0, dy=-1)
elif key == tcod.event.K_j:
action = Action(ActionType.MOVEMENT, dx=0, dy=1)
elif key == tcod.event.K_k:
action = Action(ActionType.MOVEMENT, dx=1, dy=0)
elif key == tcod.event.K_h:
action = Action(ActionType.MOVEMENT, dx=-1, dy=0)
elif key == tcod.event.K_y:
action = Action(ActionType.MOVEMENT, dx=-1, dy=-1)
elif key == tcod.event.K_i:
action = Action(ActionType.MOVEMENT, dx=1, dy=-1)
elif key == tcod.event.K_n:
action = Action(ActionType.MOVEMENT, dx=-1, dy=1)
elif key == tcod.event.K_m:
action = Action(ActionType.MOVEMENT, dx=1, dy=1)
return action
def create_new_job(self, created_actions: List[ActionToCreate]):
"""Creates a job that will be performed on the songs
"""
created_job: List[Action] = []
for index, created_action in enumerate(created_actions):
action = Action(created_action, self.job_index, index)
action.signals.action_started.connect(self.set_action_length)
action.signals.action_progress\
.connect(self.update_action_progress)
action.signals.action_finished\
.connect(self.update_action_complete)
if action.subaction_signals is not None:
action.subaction_signals.subaction_started\
.connect(self.set_subaction_length)
action.subaction_signals.subaction_progress\
.connect(self.update_subaction_progress)
action.subaction_signals.subaction_finished\
.connect(self.update_subaction_complete)
created_job.append(action)
self.add_to_current_jobs(created_job)
import json
from actions import Action
print "Running HoursFillerCmd"
act = Action()
act.login()
act.remove_all_existing()
exit(0)
d = dict(project="GO-LAB", unit="Unidad Internet", concept="I+D Desarrollo Proyecto", date="1/1/2014", hours="1")
act.add_entry(**d)
act.add_entry(**d)
act.add_entry(**d)
entries_raw = open("entries.json").read()
entries = json.loads(entries_raw)
act.add_entries(entries["entries"])
def doDealDamage(self, list, combat=False):
dr = DamageReplacement(list, combat)
self.raise_event("damage_replacement", dr)
for a_lki_id, b_lki_id, n in dr.list:
if not self.lki(b_lki_id).is_moved():
# go through all applicable damage prevention effects
applicable = []
for damage_prevention in self.damage_preventions:
if damage_prevention.canApply(self, (a_lki_id, b_lki_id, n), combat):
applicable.append (damage_prevention)
while len(applicable) > 0:
# do we have a unique applicable effect?
if len(applicable) == 1:
a_lki_id,b_lki_id,n = applicable[0].apply(self, (a_lki_id, b_lki_id, n), combat)
applicable = []
else:
# we let the reciever's controller choose
# TODO: make threadless
controller = self.objects[self.lki(b_lki_id).get_controller_id()]
actions = []
for damage_prevention in applicable:
action = Action()
action.text = damage_prevention.getText()
action.damage_prevention = damage_prevention
actions.append(action)
_as = ActionSet (self, controller, "Which damage prevention effect apply first for %d damage to %s?" % (n, str(self.lki(b_lki_id))), actions)
action = self.input.send (_as)
damage_prevention = action.damage_prevention
a_lki_id,b_lki_id,n = damage_prevention.apply(self, (a_lki_id,b_lki_id,n), combat)
applicable.remove(damage_prevention)
if n <= 0:
break
new_applicable = []
for damage_prevention in applicable[:]:
if damage_prevention.canApply(self, (a_lki_id,b_lki_id,n), combat):
new_applicable.append(damage_prevention)
applicable = new_applicable
if n <= 0:
continue
if combat:
self.raise_event("pre_deal_combat_damage", a_lki_id, b_lki_id, n)
self.raise_event("pre_deal_damage", a_lki_id, b_lki_id, n)
a = self.lki(a_lki_id)
b = self.lki(b_lki_id)
if "player" in b.get_state().types:
if "damage that would reduce your life total to less than 1 reduces it to 1 instead" in b.get_state().tags and (b.get_object().life - n < 1):
b.get_object().life = 1
else:
b.get_object().life -= n
else:
b.get_object().damage += n
self.output.damage(a.get_object(), b.get_object, n)
if combat:
self.raise_event("post_deal_combat_damage", a_lki_id, b_lki_id, n)
self.raise_event("post_deal_damage", a_lki_id, b_lki_id, n)
def on_receive(self, msg):
logger.debug("Received admin command: %s" % msg)
cmd = msg.get('command', '')
if cmd.count('.') == 1:
subject, action = cmd.split('.')
# hosts
if subject == 'hosts':
# .list
if action == 'list':
return {'hosts': [n.to_json() for n in Session.query(Host).filter(Host.acknowledged==True)]}
# .details
elif action == 'details':
host = Session.query(Host).filter(Host.id==msg['args'][0]).first()
return {'host': host.to_json()}
# autohosts
elif subject == 'autohosts':
# .list
if action == 'list':
return {'hosts': [n.to_json() for n in Session.query(Host).filter(Host.acknowledged==False)]}
# .add
elif action == 'add':
host = Session.query(Host).filter(Host.id==msg['args'][0]).first()
host.acknowledged = True
host.key = uuid4()
Session.add(host)
Session.commit()
return {'key': host.key}
# .decline
elif action == 'decline':
host = Session.query(Host).filter(Host.id==msg['args'][0]).first()
Session.delete(host)
Session.commit()
return {}
# values
elif subject == 'values':
# .latest
if action == 'latest':
host = Session.query(Host).filter(Host.id==msg['args'][0]).first()
return {'values': [v.to_json() for v in host.reports[-1].values.all()]}
# triggers
elif subject == 'triggers':
# .list
if action == 'list':
return {'triggers': [t.to_json() for t in Session.query(Trigger).all()]}
# .add
if action == 'add':
trigger = Trigger(
host_id = msg['args'][0]['host'],
name = msg['args'][0]['name'],
description = msg['args'][0]['description'],
expression = msg['args'][0]['expression'],
action = msg['args'][0]['action']
)
Session.add(trigger)
Session.commit()
return {'id': trigger.id}
# actions
elif subject == 'actions':
# .list
if action == 'list':
return {'actions': Action.get_actions()}
else:
raise PackageError('Missing or invalid command')
def post(self):
user = users.get_current_user()
if not user:
self.error(403) # access denied
return
client = get_client(user)
if not client:
self.error(403) # access denied
return
#debug = self.request.get('debug', False)
# CAUTION: IT WANNA BE BY ANOTHER WAY (NEED TO IMPLEMENT)
#char.logged = True
#char.put()
#self.response.headers.add_header("Content-Type", 'application/json')
# Action to execute
action = self.request.get('action')
# Arguments of the action
args = self.request.get_all('args[]')
# REMOVE ALL EMPTY VALUE OF THE ARGS
for i in range(args.count('')):
args.remove('')
# Target of the action
target_id = self.request.get('target')
if target_id:
target = db.get(db.Key(target_id))
# DEBUG
if not target:
response['alert'].append('TARGET NOT AVAILABLE')
else:
target = None
# Client time that executed the action
client_time = self.request.get('time')
# Append to the response the action feedback or one alert or error if it has
response = {
'action': action,
'target': target,
'args': args,
'client_time': client_time,
#'server_hour': datetime.datetime.now().strftime('%I:%M:%S'),
'self': client.char.id,
#'object': {}, Thinking about it here in action_handler
#'listener': {}, Not implemented yet
'alert': [],
'error': [],
}
if action == 'ping':
pass
elif action == 'get_channel_token':
client.channel_token = create_channel(client.id)
client.put()
response['channel_token'] = client.channel_token
elif action in actions_signatures:
#response['alert'].append('Action found:' + action)
if validate_args(actions_signatures[action], args):
#function = getattr(actions, action)
#function(client, response, args)
query = db.Query(Action)
query.filter('active =', True)
query.filter('action =', action)
query.filter('char =', client.char)
saved_action = query.get()
if saved_action:
response['alert'].append('ACTION ACTIVE FOUND')
saved_action.args = args
saved_action.target = target
saved_action.put()
else:
response['alert'].append('NEW ACTION CREATED')
action = Action(char=client.char,
action=action,
args=args,
target=target)
action.put()
else:
response['error'].append('ERROR TO VALIDATE ARGS')
else:
response['error'].append('ACTION NOT ALLOWED')
self.response.out.write(simplejson.dumps(response))
return
def test_Action_run(self, run):
action = Action([Step('url1'), Step('url2')])
action.run()
self.assertEqual(run.call_count, 2)
# Full script.
from actions import Action
import config
if __name__ == "__main__":
# Load the calendar.
import json
import optimize
calendar = json.loads(open("dt.json").read())
split = json.loads(open("my.split.json").read())
entries = optimize.split_to_entries(calendar, split)
act = Action()
act.login()
if config.REMOVE_BEFORE_ADD:
act.remove_all_existing()
act.add_entries_safe(entries, "my.progress.json")
