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 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