def get_params(self):
"""Paper over webapp2 weirdness, do type coercion and filtering."""
# JSON data in POSTs and PUTs require extra work.
if (self.request.method in ['POST', 'PUT'] and 'application/json'
in self.request.headers['Content-Type']):
raw_params = self.process_json_body()
else:
raw_params = {
k: self.request.get(k)
for k in self.request.arguments()
}
params = {}
for k, v in raw_params.items():
if k in config.ignored_url_arguments:
continue
# Convert some special tokens into values that otherwise can't be
# easily sent in a request string, e.g. None
if isinstance(v, collections.Hashable) and v in config.url_values:
v = config.url_values[v]
if k[-5:] == '_json':
# this value should be interpreted as json AND renamed w/o suffix
params[k[:-5]] = json.loads(v)
elif k in config.boolean_url_arguments:
# Sending a javascript boolean via POST results in v being a
# python native bool here. If via GET, it comes as str 'true'.
if isinstance(v, bool):
params[k] = v
else:
params[k] = str(v) in config.true_strings
elif k in config.integer_url_arguments:
params[k] = int(v)
elif k in config.date_url_arguments:
params[k] = util.parse_datetime(v, 'date')
elif k in config.datetime_url_arguments:
params[k] = util.parse_datetime(v, 'datetime')
elif k in config.list_url_arguments:
# POST, PUT use json, whereas GET uses separate arguments
if (self.request.method in ['POST', 'PUT']):
params[k] = json.loads(v)
else:
params[k] = self.request.get_all(k)
elif k in config.json_url_arguments:
params[k] = json.loads(v)
else:
params[k] = v
for k, v in params.items():
if k in config.json_url_arguments_with_numeric_keys:
params[k] = {int(str_key): val for str_key, val in v.items()}
return params
def __init__(self, gdocs_line):
self.type = gdocs_line[0]
self.num_people = int(gdocs_line[1])
self.starts = parse_datetime(gdocs_line[2])
self.ends = parse_datetime(gdocs_line[3])
self.needs_license = bool(int(gdocs_line[4]))
self.is_kitchen = bool(int(gdocs_line[5]))
self.is_bar = bool(int(gdocs_line[6]))
self.is_high_tempo = bool(int(gdocs_line[7]))
if HALF_LOAD:
self.num_people = self.num_people // 2
def from_dict(cls, dct): # type: (dict) -> ResponseStatus
"""
:param dct:
:return:
"""
response_status = cls()
if "code" in dct:
response_status.code = dct.pop("code")
else:
return None
if "response" in dct:
response_status.response = dct.pop("response")
if "message" in dct:
response_status.message = dct.pop("message")
if "serverID" in dct:
response_status.server_id = dct.pop("serverID")
if "datetime" in dct:
response_status.date_time = parse_datetime(dct.pop("datetime"))
return response_status
def get(self):
"""Return all of the Players.
Returns:
A list of player object, ordered by:
1) Rating descending.
2) Number of games played descending.
3) Join date ascending.
"""
query = Player.query.all()
marshalled = schemas.players_schema.dump(query)
if marshalled.errors:
return marshalled.errors, 500
players = sorted(
marshalled.data,
key=lambda player: (
-player['rating'],
-(player['num_wins'] + player['num_losses']),
util.parse_datetime(player['time_created'])
)
)
return players, 200
def add_appt(self, fields, row):
dt = parse_datetime(fields, row)
type = row[fields.index('Type')]
if dt in self.appts:
raise ValueError('Patient %d already has an appt at %s' %
(self.id, dt))
self.appts[dt] = type
def from_dict(cls, dct): # type: (dict) -> StatusSystem
"""
:param dct:
:type dct: dict
:return:
:rtype: StatusSystem
"""
system_status = cls()
if "date" in dct:
system_status.date = parse_datetime(dct.pop("date"))
if "details" in dct:
system_status.details = dct.pop("details")
if "status" in dct:
system_status.status = dct.pop("status")
if "message" in dct:
system_status.message = dct.pop("message")
if len(dct) != 0:
logging.warn("Key(s) not processed for StatusSystem: %s",
", ".join(dct.keys()))
return system_status
def from_dict(cls, dct): # type: (dict) -> Lineup
"""
:param dct:
:return:
"""
lineup = cls()
lineup.lineup_id = dct.pop("lineup")
if "name" in dct:
lineup.name = dct.pop("name")
if "transport" in dct:
lineup.transport = dct.pop("transport")
if "location" in dct:
lineup.location = dct.pop("location")
if "modified" in dct:
lineup.modified = parse_datetime(dct.pop("modified"))
if "uri" in dct:
lineup.uri = dct.pop("uri")
if "isDeleted" in dct:
lineup.is_deleted = dct.pop("isDeleted")
if len(dct) != 0:
logging.warn("Key(s) not processed for Lineup: %s", ", ".join(dct.keys()))
return lineup
def from_dict(cls, dct): # type: (dict) -> Lineup
"""
:param dct:
:return:
"""
lineup = cls()
lineup.lineup_id = dct.pop("lineup")
if "name" in dct:
lineup.name = dct.pop("name")
if "transport" in dct:
lineup.transport = dct.pop("transport")
if "location" in dct:
lineup.location = dct.pop("location")
if "modified" in dct:
lineup.modified = parse_datetime(dct.pop("modified"))
if "uri" in dct:
lineup.uri = dct.pop("uri")
if "isDeleted" in dct:
lineup.is_deleted = dct.pop("isDeleted")
if len(dct) != 0:
logging.warn("Key(s) not processed for Lineup: %s",
", ".join(dct.keys()))
return lineup
def get(self, id):
"""Fetch entry by id. Raises :exc:`Entry.Empty` if the entry is
unfound. Blocking."""
data = raw_query(
action='display_message',
id=int(id),
language='sv',
)
token_order = ['title', 'mail1', 'submitted', 'body', 'mail2', 'report']
cur_token_id = 0
title = u''
submitted = None
body = u''
mail = u''
token = None
for line in data.splitlines()[1:-1]:
token = token_order[cur_token_id]
line = line.strip()
if token == 'title':
title = regex.MATCH_H3.match(line).groups()[0]
cur_token_id += 1
elif token == 'mail1':
mail = regex.MATCH_MAIL.match(line).groups()[0]
cur_token_id += 1
elif token == 'submitted':
try:
submitted = parse_datetime(
regex.MATCH_DATETIME.match(line).groups()[0]
)
except:
pass
cur_token_id += 1
elif token == 'body':
start_p = '<p>'
end_p = '</p>'
ends_now = line.endswith(end_p)
body += line.replace(start_p, '').replace(end_p, '')
if ends_now:
cur_token_id += 1
else:
body += '\n'
elif token == 'mail2':
cur_token_id += 1
elif token == 'report':
break
assert token == token_order[-1]
if not title and not body:
raise Entry.Empty('empty entry %s' % id)
return Entry(id, title, mail, submitted, body)
def from_dict(cls, dct): # type: (dict) -> Status
"""
:param dct:
:return:
"""
status = cls()
if "account" in dct:
status.account = StatusAccount.from_dict(dct.pop("account"))
if "lineups" in dct:
status.lineups = Lineup.from_iterable(dct.pop("lineups"))
if "lastDataUpdate" in dct:
status.last_data_update = parse_datetime(dct.pop("lastDataUpdate"))
if "notifications" in dct:
status.notifications = dct.pop("notifications")
if "systemStatus" in dct:
if len(dct["systemStatus"]) != 0:
status.system_status = StatusSystem.from_dict(
dct.pop("systemStatus")[0])
if "serverID" in dct:
status.server_id = dct.pop("serverID")
if "code" in dct:
status.code = dct.pop("code")
if "datetime" in dct:
status.datetime = parse_datetime(dct.pop("datetime"))
if len(dct) != 0:
logging.warn("Key(s) not processed for Status: %s",
", ".join(dct.keys()))
return status
def from_dict(cls, dct): # type: (dict) -> Status
"""
:param dct:
:return:
"""
status = cls()
if "account" in dct:
status.account = StatusAccount.from_dict(dct.pop("account"))
if "lineups" in dct:
status.lineups = Lineup.from_iterable(dct.pop("lineups"))
if "lastDataUpdate" in dct:
status.last_data_update = parse_datetime(dct.pop("lastDataUpdate"))
if "notifications" in dct:
status.notifications = dct.pop("notifications")
if "systemStatus" in dct:
if len(dct["systemStatus"]) != 0:
status.system_status = StatusSystem.from_dict(dct.pop("systemStatus")[0])
if "serverID" in dct:
status.server_id = dct.pop("serverID")
if "code" in dct:
status.code = dct.pop("code")
if "datetime" in dct:
status.datetime = parse_datetime(dct.pop("datetime"))
if len(dct) != 0:
logging.warn("Key(s) not processed for Status: %s", ", ".join(dct.keys()))
return status
def post(self):
"""Takes student data and cohort info, and inserts into db."""
api = Api() # interface to SQL instance
cohort_code = self.request.get('cohort_code')
anonymous_link = self.request.get('anonymous_link')
panel_string = self.request.get('panel')
# Insert a new cohort.
if cohort_code and anonymous_link:
if re.match(config.cohort_code_regex, cohort_code) is None:
self.response.write("Invalid cohort code.")
return
if re.match(config.anonymous_link_regex, anonymous_link) is None:
self.response.write("Invalid link.")
return
success = api.insert('cohorts', {
'cohort_code': cohort_code,
'anonymous_link': anonymous_link,
})
self.response.write(success) # 'True' or error message.
return
elif cohort_code and panel_string:
# These come in as a tab-and-newline-separated string; convert to
# list of dictionaries. The db will accept only certain fields.
# Including others will cause an error (our js should provide clean
# data).
raw_row_dicts = api.csv_to_dicts(panel_string)
# Add the cohort code to each token row, and convert each
# expiration date from an american-style string to an iso standard
# string.
row_dicts = []
for row in raw_row_dicts:
row['cohort_code'] = cohort_code
exp_datetime = util.parse_datetime(row['link_expiration'])
row['link_expiration'] = exp_datetime.isoformat()
row_dicts.append(row)
success = api.insert('map', row_dicts)
self.response.write(success) # 'True' or error message.
else:
self.response.write("Invalid POST data.")
def from_dict(cls, dct): # type: (dict) -> StatusAccount
"""
:param dct:
:return:
"""
status_account = cls()
if "expires" in dct:
status_account.expires = parse_datetime(dct.pop("expires"))
if "messages" in dct:
status_account.messages = dct.pop("messages")
if "maxLineups" in dct:
status_account.max_lineups = dct.pop("maxLineups")
if len(dct) != 0:
logging.warn("Key(s) not processed for StatusAccount: %s", ", ".join(dct.keys()))
return status_account
def from_dict(cls, dct): # type: (dict) -> ScheduleMetadata
"""
:param dct:
:type dct: dict
:return:
:rtype: ScheduleMetadata
"""
schedule_metadata = cls()
schedule_metadata.modified = parse_datetime(dct.pop("modified"))
schedule_metadata.md5 = dct.pop("md5")
schedule_metadata.start_date = parse_date(dct.pop("startDate"))
# optional
if "code" in dct:
schedule_metadata.code = dct.pop("code")
if len(dct) != 0:
logging.warn("Key(s) not processed for ScheduleMetadata: %s", ", ".join(dct.keys()))
return schedule_metadata
def __init__(self,
id,
appliance,
type,
image,
resources,
cmd=None,
args=[],
env={},
volumes=[],
network_mode=NetworkMode.HOST,
endpoints=[],
ports=[],
state=ContainerState.SUBMITTED,
is_privileged=False,
force_pull_image=True,
dependencies=[],
last_update=None,
user_schedule_hints=None,
sys_schedule_hints=None,
deployment=None,
*aargs,
**kwargs):
self.__id = id
self.__appliance = appliance
self.__type = type if isinstance(
type, ContainerType) else ContainerType(type)
self.__image = image
self.__resources = Resources(**resources)
self.__cmd = cmd and str(cmd)
self.__args = [a and str(a) for a in args]
if self.__cmd and self.__args:
raise ValueError("Cannot specify both 'cmd' and 'args'")
self.__env = {
k: v if v and isinstance(v, str) else json.dumps(v)
for k, v in env.items()
}
self.__volumes = [ContainerVolume(**v) for v in volumes]
self.__network_mode = network_mode if isinstance(network_mode, NetworkMode) \
else NetworkMode(network_mode.upper())
self.__endpoints = [Endpoint(**e) for e in endpoints]
self.__ports = [Port(**p) for p in ports]
self.__state = state if isinstance(
state, ContainerState) else ContainerState(state)
self.__is_privileged = is_privileged
self.__force_pull_image = force_pull_image
self.__dependencies = list(dependencies)
if isinstance(user_schedule_hints, dict):
self.__user_schedule_hints = ContainerScheduleHints(
**user_schedule_hints)
elif isinstance(user_schedule_hints, ContainerScheduleHints):
self.__user_schedule_hints = user_schedule_hints
else:
self.__user_schedule_hints = ContainerScheduleHints()
if isinstance(sys_schedule_hints, dict):
self.__sys_schedule_hints = ContainerScheduleHints(
**sys_schedule_hints)
elif isinstance(sys_schedule_hints, ContainerScheduleHints):
self.__sys_schedule_hints = sys_schedule_hints
else:
self.__sys_schedule_hints = ContainerScheduleHints()
if isinstance(deployment, dict):
self.__deployment = ContainerDeployment(**deployment)
elif isinstance(deployment, ContainerDeployment):
self.__deployment = deployment
else:
self.__deployment = ContainerDeployment()
self.__last_update = parse_datetime(last_update)
def filter_reports(all):
for ticket in all:
ticket['reports'] = list(reversed(sorted(current_reports(ticket), key=lambda report: parse_datetime(report['time']))))[:10]
for report in ticket['reports']:
report['plugins'] = '...'
yield ticket
def last_update(self, last_update):
self.__last_update = parse_datetime(last_update)
def _deserialize(self, value):
return util.parse_datetime(value)
def from_dict(cls, dct): # type: (dict) -> Broadcast
"""
:param dct:
:return:
"""
broadcast = cls()
broadcast.program_id = dct.pop("programID")
broadcast.md5 = dct.pop("md5")
broadcast.air_date_time = parse_datetime(dct.pop("airDateTime"))
broadcast.duration = dct.pop("duration")
if "liveTapeDelay" in dct:
broadcast.live_tape_delay = dct.pop("liveTapeDelay")
if "isPremiereOrFinale" in dct:
broadcast.is_premiere_or_finale = dct.pop("isPremiereOrFinale")
if "new" in dct:
broadcast.is_new = dct.pop("new")
if "cableInTheClassroom" in dct:
broadcast.is_cable_in_the_classroom = dct.pop("cableInTheClassroom")
if "catchup" in dct:
broadcast.is_catchup = dct.pop("catchup")
if "continued" in dct:
broadcast.is_continued = dct.pop("continued")
if "educational" in dct:
broadcast.is_educational = dct.pop("educational")
if "joinedInProgress" in dct:
broadcast.is_joined_in_progress = dct.pop("joinedInProgress")
if "leftInProgress" in dct:
broadcast.is_left_in_progress = dct.pop("leftInProgress")
if "premiere" in dct:
broadcast.is_premiere = dct.pop("premiere")
if "programBreak" in dct:
broadcast.is_program_break = dct.pop("programBreak")
if "repeat" in dct:
broadcast.is_repeat = dct.pop("repeat")
if "signed" in dct:
broadcast.is_signed = dct.pop("signed")
if "subjectToBlackout" in dct:
broadcast.is_subject_to_blackout = dct.pop("subjectToBlackout")
if "timeApproximate" in dct:
broadcast.is_time_approximate = dct.pop("timeApproximate")
if "audioProperties" in dct:
broadcast.audio_properties = dct.pop("audioProperties")
if "videoProperties" in dct:
broadcast.video_properties = dct.pop("videoProperties")
if "multipart" in dct:
broadcast.multipart = MultipartBroadcast.from_dict(dct.pop("multipart"))
# ratings in Broadcast is deprecated so just pop if found
if "ratings" in dct:
dct.pop("ratings")
if "parentalAdvisory" in dct:
broadcast.parental_advisory = dct.pop("parentalAdvisory")
if len(dct) != 0:
logging.warn("Key(s) not processed for Broadcast: %s", ", ".join(dct.keys()))
return broadcast
