def validate(new, old, userctx, secobj): """ Validate this flight document against the schema, then check that only managers are approving documents and approved documents are only edited by managers. """ global schema if not schema: schema = read_json_schema("flight.json") validate_doc(new, schema) if '_admin' in userctx['roles']: return if new['approved'] and 'manager' not in userctx['roles']: raise UnauthorizedError("Only managers may approve documents.") if old and 'manager' not in userctx['roles']: raise UnauthorizedError("Only managers may edit documents.") start = rfc3339_to_timestamp(new['start']) end = rfc3339_to_timestamp(new['end']) launch = rfc3339_to_timestamp(new['launch']['time']) if start > end: raise ForbiddenError("Launch window may not end before it starts.") if end - start > 7 * 24 * 3600: raise ForbiddenError("Launch window may not be greater than one week" " (speak to an admin if you have a special requirement).") if not start <= launch < end: raise ForbiddenError("Launch time must be within launch window.") if 'payloads' in new: payloads = new['payloads'] if len(payloads) != len(set(payloads)): raise ForbiddenError("Duplicate entries in payloads list")
def __init__(self, event): try: self.location = event['location'] except KeyError: self.location = None self.id = event['id'] try: self.html_link = event['htmlLink'] except KeyError: self.html_link = None self.end_timestamp = rfc.rfc3339_to_timestamp(event['end']['dateTime']) self.start_timestamp = rfc.rfc3339_to_timestamp(event['start']['dateTime']) self.start_datetime = datetime.datetime.fromtimestamp(self.start_timestamp) self.end_datetime = datetime.datetime.fromtimestamp(self.end_timestamp) self.start_year = self.start_datetime.year self.start_month=self.start_datetime.month self.start_day=self.start_datetime.day self.start_time=self._format_time(self.start_datetime) self.end_year=self.end_datetime.year self.end_month=self.end_datetime.month self.end_day=self.end_datetime.day self.end_time=self._format_time(self.end_datetime) self.summary = event['summary'] try: self.description = event['description'] except KeyError: self.description = None self.status = event['status']
def _generate_query(query: dict): if query: match_dict = dict() date_dict = dict() new_query = {'bool': {}} for key, value in query.items(): if key == 'dateFrom': date_dict['gte'] = rfc3339_to_timestamp(value) elif key == 'dateTo': date_dict['lte'] = rfc3339_to_timestamp(value) else: match_dict[key] = value if match_dict: new_query['bool']['must'] = [{ 'match': { key: value } } for key, value in match_dict.items()] if date_dict: new_query['bool']['filter'] = {'range': {'date': date_dict}} return new_query else: return {'match_all': {}}
async def test_get_non_existant(jp_fetch, labserverapp): id = "foo" r = await jp_fetch("lab", "api", "workspaces", id) validate_request(r) data = json.loads(r.body.decode()) r2 = await jp_fetch("lab", "api", "workspaces", id, method="PUT", body=json.dumps(data)) validate_request(r2) r3 = await jp_fetch("lab", "api", "workspaces", id) validate_request(r3) data = json.loads(r3.body.decode()) first_metadata = data["metadata"] first_created = rfc3339_to_timestamp(first_metadata["created"]) first_modified = rfc3339_to_timestamp(first_metadata["last_modified"]) r4 = await jp_fetch("lab", "api", "workspaces", id, method="PUT", body=json.dumps(data)) validate_request(r4) r5 = await jp_fetch("lab", "api", "workspaces", id) validate_request(r5) data = json.loads(r5.body.decode()) second_metadata = data["metadata"] second_created = rfc3339_to_timestamp(second_metadata["created"]) second_modified = rfc3339_to_timestamp(second_metadata["last_modified"]) assert first_created <= second_created assert first_modified < second_modified
def test_now(self): s = strict_rfc3339.now_to_rfc3339_utcoffset() assert s[-1] == "Z" assert len(s) == 20 d = int(time.time()) - strict_rfc3339.rfc3339_to_timestamp(s) assert d == 0 or d == 1 s = strict_rfc3339.now_to_rfc3339_utcoffset(False) assert abs(strict_rfc3339.rfc3339_to_timestamp(s) - time.time()) <= 0.1
async def test_patch(jp_fetch, labserverapp): id = "@jupyterlab/shortcuts-extension:plugin" r = await jp_fetch("lab", "api", "settings", id, method="PUT", body=json.dumps(dict(raw=json5.dumps(dict())))) validate_request(r) r = await jp_fetch( "lab", "api", "settings", id, method="GET", ) validate_request(r) data = json.loads(r.body.decode()) first_created = rfc3339_to_timestamp(data["created"]) first_modified = rfc3339_to_timestamp(data["last_modified"]) r = await jp_fetch("lab", "api", "settings", id, method="PUT", body=json.dumps(dict(raw=json5.dumps(dict())))) validate_request(r) r = await jp_fetch( "lab", "api", "settings", id, method="GET", ) validate_request(r) data = json.loads(r.body.decode()) second_created = rfc3339_to_timestamp(data["created"]) second_modified = rfc3339_to_timestamp(data["last_modified"]) assert first_created <= second_created assert first_modified < second_modified r = await jp_fetch( "lab", "api", "settings/", method="GET", ) validate_request(r) data = json.loads(r.body.decode()) listing = data["settings"] list_data = [item for item in listing if item["id"] == id][0]
async def test_patch(jp_fetch, labserverapp): id = '@jupyterlab/shortcuts-extension:plugin' r = await jp_fetch('lab', 'api', 'settings', id, method='PUT', body=json.dumps(dict(raw=json5.dumps(dict())))) validate_request(r) r = await jp_fetch( 'lab', 'api', 'settings', id, method='GET', ) validate_request(r) data = json.loads(r.body.decode()) first_created = rfc3339_to_timestamp(data['created']) first_modified = rfc3339_to_timestamp(data['last_modified']) r = await jp_fetch('lab', 'api', 'settings', id, method='PUT', body=json.dumps(dict(raw=json5.dumps(dict())))) validate_request(r) r = await jp_fetch( 'lab', 'api', 'settings', id, method='GET', ) validate_request(r) data = json.loads(r.body.decode()) second_created = rfc3339_to_timestamp(data['created']) second_modified = rfc3339_to_timestamp(data['last_modified']) assert first_created <= second_created assert first_modified < second_modified r = await jp_fetch( 'lab', 'api', 'settings/', method='GET', ) validate_request(r) data = json.loads(r.body.decode()) listing = data['settings'] list_data = [item for item in listing if item['id'] == id][0]
def test_now(self): s = strict_rfc3339.now_to_rfc3339_localoffset() w = strict_rfc3339.rfc3339_to_timestamp(s) assert s[-6:] == ["-05:00", "-04:00"][time.localtime(w).tm_isdst] d = int(time.time()) - w assert d == 0 or d == 1 s = strict_rfc3339.now_to_rfc3339_localoffset(False) assert abs(strict_rfc3339.rfc3339_to_timestamp(s) - time.time()) <= 0.1
def is_alive(self): current_epoch = strict_rfc3339.rfc3339_to_timestamp( self.get_current_utc()) last_pet_epoch = strict_rfc3339.rfc3339_to_timestamp( self.get_last_pet()) delta_t = current_epoch - last_pet_epoch if delta_t > self.timeout: return False else: return True
async def test_get(fetch, labserverapp): id = 'foo' r = await fetch('lab', 'api', 'workspaces', id) data = json.loads(r.body.decode()) metadata = data['metadata'] assert metadata['id'] == id assert rfc3339_to_timestamp(metadata['created']) assert rfc3339_to_timestamp(metadata['last_modified']) r2 = await fetch('lab', 'api', 'workspaces', id) assert r2.code == 200 data = json.loads(r.body.decode()) assert data['metadata']['id'] == id
def end_start_including_payloads_map(doc): """ View: ``flight/end_start_including_payloads`` Emits:: [end_time, start_time, flight_id, 0] -> [payload_configuration ids] [end_time, start_time, flight_id, 1] -> {linked payload_configuration doc 1} [end_time, start_time, flight_id, 1] -> {linked payload_configuration doc 2} ... Or, when a flight has no payloads:: [end_time, start_time, flight_id, 0] -> null Times are all UNIX timestamps (and therefore in UTC). Sorts by flight window end time then start time. If the flight has payloads, emit it with the list of payloads, and emit a link for each payload so that they get included with include_docs. If a flight does not have payloads, it is emitted by itself. Only shows approved flights. Used by the parser to find active flights and get the configurations used to decode telemetry from them. May otherwise be used to find upcoming flights and their associated payloads, though typically the view ``launch_time_including_payloads`` would be more useful as it sorts by launch time. Query using ``startkey=[current_timestamp]`` to get all flights whose windows have not yet ended. Use ``include_docs=true`` to have the linked payload_configuration documents fetched and returned as the ``"doc"`` key for that row, otherwise the row's value will just contain an object that holds the linked ID. See the `CouchDB documentation <http://wiki.apache.org/couchdb/Introduction_to_CouchDB_views#Linked_documents>`_ for details on linked documents. """ if doc['type'] != "flight" or not doc['approved']: return flight_id = doc['_id'] et = rfc3339_to_timestamp(doc['end']) st = rfc3339_to_timestamp(doc['start']) if 'payloads' in doc: yield (et, st, flight_id, 0), doc['payloads'] for payload in doc['payloads']: yield (et, st, flight_id, 1), {'_id': payload} else: yield (et, st, flight_id, 0), None
async def test_get(jp_fetch, labserverapp): id = "foo" r = await jp_fetch("lab", "api", "workspaces", id) validate_request(r) data = json.loads(r.body.decode()) metadata = data["metadata"] assert metadata["id"] == id assert rfc3339_to_timestamp(metadata["created"]) assert rfc3339_to_timestamp(metadata["last_modified"]) r2 = await jp_fetch("lab", "api", "workspaces", id) validate_request(r2) data = json.loads(r.body.decode()) assert data["metadata"]["id"] == id
def tx_ledger_time(txs, log_path): """Process load testing log and print time difference of transaction submission time to horizon and commit time to ledger, and horizon response time.""" logging.debug('reading logs ...') tx_time_diffs = {} with open(log_path, 'r') as f: for i, raw_line in enumerate(f): if i % 100 == 0: logging.debug('processing line %d', i) json_line = json.loads(raw_line) # ignore lines missing tx hash (events we're not interested in) tx_hash = json_line.get('tx_hash') if not tx_hash: continue # get transaction hash from all submitted transactions if json_line.get('msg') == 'submitting transaction': # process only the first result of every transaction submit attempt, ignore retries if tx_hash not in tx_time_diffs: tx_time_diffs[tx_hash] = { 'horizon_submit_timestamp': strict_rfc3339.rfc3339_to_timestamp( json_line['timestamp']), # commit to ledger timestamp 'commit_to_ledger_timestamp': strict_rfc3339.rfc3339_to_timestamp( txs[tx_hash]['created_at']) } elif json_line.get('transaction_status'): # process only the first result of every transaction submit attempt, ignore retries tx = tx_time_diffs[tx_hash] if 'status' not in tx: tx.update({ 'horizon_response_timestamp': strict_rfc3339.rfc3339_to_timestamp( json_line['timestamp']), 'status': json_line['transaction_status'], }) w = csv.DictWriter(sys.stdout, fieldnames=['tx_hash'] + list(list(tx_time_diffs.values())[0].keys())) w.writeheader() for tx_hash, tx in tx_time_diffs.items(): w.writerow({'tx_hash': tx_hash, **tx})
def convert( self, value: ty.Any, path: Path, *args: ty.Any, entity: ty.Optional[ConvertibleEntity] = None, **context: ty.Any ) -> ty.Optional[ty.Union[str, datetime.datetime]]: if isinstance( value, datetime.datetime ) and entity == ConvertibleEntity.RESPONSE and value is not None: value = rfc3339.rfc3339(value) result = self.subtype.convert(value, path, *args, entity=entity, **context) if entity == ConvertibleEntity.RESPONSE: return result if result is None: return None try: return datetime.datetime.fromtimestamp(rfc3339_to_timestamp(value)) except InvalidRFC3339Error: raise SchemaError(Error(path, self.messages['format']))
def _assert_init(self, kwargs): """Run __init__ assertions. Args: kwargs (dict): keyword arguments for the Token initializer. Raises: AssertionError: Token attributes is not set as expected. """ token = Token(**kwargs) if 'bucket' in kwargs: assert token.bucket_id == kwargs['bucket'] else: assert token.bucket_id is None if 'expires' in kwargs: assert token.expires == datetime.fromtimestamp( strict_rfc3339.rfc3339_to_timestamp(kwargs['expires'])) else: assert token.expires is None if 'operation' in kwargs: assert token.operation == kwargs['operation'] else: assert token.operation is None if 'token' in kwargs: assert token.id == kwargs['token'] else: assert token.id is None
def from_rfc3339(rfc3339_text, with_nanos=False): """Parse a RFC 3339 date string format to datetime.date. Example of accepted format: '1972-01-01T10:00:20.021-05:00' - By default, the result is a datetime.datetime - If with_nanos is true, the result is a 2-tuple, (datetime.datetime, nanos), where the second field represents the possible nanosecond resolution component of the second field. Args: rfc3339_text (string): An rfc3339 formatted date string with_nanos (bool): Determines if nanoseconds should be parsed from the string Raises: ValueError: if ``rfc3339_text`` is invalid Returns: :class:`datetime.datetime`: when with_nanos is False tuple(:class:`datetime.datetime`, int): when with_nanos is True """ timestamp = strict_rfc3339.rfc3339_to_timestamp(rfc3339_text) result = datetime.datetime.utcfromtimestamp(timestamp) if with_nanos: return (result, int((timestamp - int(timestamp)) * 1e9)) else: return result
def _parse_time(input): """ :param input: Either a number as milliseconds since Unix Epoch, or a string as a valid RFC3339 timestamp :return: milliseconds since Unix epoch, or None if input was invalid. """ # bool is a subtype of int, and we don't want to try and compare it as a time. if isinstance(input, bool): log.warn("Got unexpected bool type when attempting to parse time") return None if isinstance(input, Number): return float(input) if isinstance(input, six.string_types): try: timestamp = strict_rfc3339.rfc3339_to_timestamp(input) return timestamp * 1000.0 except Exception as e: log.warn("Couldn't parse timestamp:" + str(input) + " with error: " + str(e)) return None log.warn("Got unexpected type: " + type(input) + " with value: " + str(input) + " when attempting to parse time") return None
def export(update, ctx): gettime = str(update.message.date).split() chatid = update.message.chat_id timetoconvert = gettime[0] + "T" + gettime[1] timestamp = strict_rfc3339.rfc3339_to_timestamp(timetoconvert) if timestart < int(timestamp): user = update.message.from_user if update.message.chat.type == "private": if checkRus(chatid): #print("123") ctx.bot.send_message( chat_id=update.message.chat_id, text= f"Вы экспортировали секретный ключ: <code>{db.getWIF(user['id'])}</code>. <b>Important:</b> Do not share this key. If you do share this key, all your YENTEN will be lost.", parse_mode="HTML") else: ctx.bot.send_message( chat_id=update.message.chat_id, text= f"You're exported secret key: <code>{db.getWIF(user['id'])}</code>. <b>Important:</b> Do not share this key. If you do share this key, all your YENTEN will be lost.", parse_mode="HTML") else: if checkRus(chatid): ctx.bot.send_message( chat_id=update.message.chat_id, text="Эта команда работает только в личных сообщениях." " Вместо этого отправьте мне личное сообщение :D") else: ctx.bot.send_message( chat_id=update.message.chat_id, text="This command only works in private messages." " Send me a private message instead :D")
def _assert_init(self, kwargs): """Run __init__ assertions. Args: kwargs (dict): keyword arguments for the Token initializer. Raises: AssertionError: Token attributes is not set as expected. """ token = Token(**kwargs) if 'bucket' in kwargs: assert token.bucket_id == kwargs['bucket'] else: assert token.bucket_id is None if 'expires' in kwargs: assert token.expires == datetime.fromtimestamp( strict_rfc3339.rfc3339_to_timestamp( kwargs['expires'])) else: assert token.expires is None if 'operation' in kwargs: assert token.operation == kwargs['operation'] else: assert token.operation is None if 'token' in kwargs: assert token.id == kwargs['token'] else: assert token.id is None
def optimize_timestamp(value: str) -> int: """ Encode timestamp into bytes. :param value: RFC3339 time string """ assert isinstance(value, str) return int(strict_rfc3339.rfc3339_to_timestamp(value))
def metadataSearch(self, searchType, searchEmail, searchFile, searchGivenName, filterType, mimeType, startDate, endDate): """ Search through metadata """ searchItem = list() startDateTs = float(getTimestamp(startDate)) endDateTs = float(getTimestamp(endDate)) for i in self.metadata: creationTs = strict_rfc3339.rfc3339_to_timestamp(i['createdDate']) #check temporal period if creationTs >= startDateTs and creationTs <= endDateTs: prunedRes = self.metadataSearchType(i, searchType, searchEmail, searchFile, searchGivenName) if prunedRes != None: #now apply filters filteredRes = self.metadataSearchFilters( filterType, prunedRes, mimeType) if filteredRes != None: searchItem.append(filteredRes) return searchItem
def lastSeen(self, value): if value is not None: self._last_seen = datetime.fromtimestamp( strict_rfc3339.rfc3339_to_timestamp(value)) else: self._last_seen = None
def setLang(update, ctx): gettime = str(update.message.date).split() timetoconvert = gettime[0] + "T" + gettime[1] timestamp = strict_rfc3339.rfc3339_to_timestamp(timetoconvert) if timestart < int(timestamp): user = update.message.from_user args = update.message.text.split(" ") language = getLang(update.message.chat_id) if update.message.chat.type == "private": if args[1] in ["en", "zh", "id", "ru"]: if args[1] == db.getLang(user["id"]): userlang = db.getLang(user["id"]) ctx.bot.send_message( chat_id=update.message.chat_id, text=lang[userlang]['setlang']['same-lang']) else: db.setLang(user["id"], args[1]) userlang = db.getLang(user["id"]) ctx.bot.send_message( chat_id=update.message.chat_id, text=lang[userlang]['setlang']['set-lang']) else: userlang = db.getLang(user["id"]) ctx.bot.send_message( chat_id=update.message.chat_id, text=lang[userlang]['setlang']['invalid-lang']) else: ctx.bot.send_message( chat_id=update.message.chat_id, text=lang[language]['error']['general']['dm-only'])
def __init__(self, id=None, name=None, status=None, user=None, created=None, storage=None, transfer=None, pubkeys=None): self.id = id self.name = name self.status = status self.user = user self.storage = storage self.transfer = transfer self.pubkeys = pubkeys # self.files = FileManager(bucket_id=self.id) # self.pubkeys = BucketKeyManager( # bucket=self, authorized_public_keys=self.pubkeys) # self.tokens = TokenManager(bucket_id=self.id) if created is not None: self.created = datetime.fromtimestamp( strict_rfc3339.rfc3339_to_timestamp(created)) else: self.created = None
def ruter(message, name=None, transporttype=None): ret = '' if name is None: # 3010370 is for Forskningsparken T-Bane stops = get_stations('Forskningsparken') else: stops = get_stations(name) for stop in stops: if stop['PlaceType'] in 'Stop': departures = get_departures(stop['ID'], transporttypes=transporttype)[:5] if len(departures) is not 0: ret = ret + stop['Name'] + ':\n' for departure in departures: mvc = departure['MonitoredVehicleJourney'] destination = mvc['DestinationName'] line = mvc['PublishedLineName'] timestamp = mvc['MonitoredCall']['ExpectedDepartureTime'] time = datetime.datetime.fromtimestamp( strict_rfc3339.rfc3339_to_timestamp(timestamp), tz=oslo) ret += ('%s %s: %s\n' % (line, destination, pretty_time(time))) message.reply(ret)
def balance(update, ctx): gettime = str(update.message.date).split() timetoconvert = gettime[0] + "T" + gettime[1] timestamp = strict_rfc3339.rfc3339_to_timestamp(timetoconvert) if timestart < int(timestamp): user = update.message.from_user userlang = db.getLang(user['id']) if update.message.chat.type == "private": if not db.checkUser(user["id"]): ctx.bot.send_message( chat_id=update.message.chat_id, text=lang[userlang]['error']['not-registered']) else: balance = getBalance(user["id"]) ctx.bot.send_message( chat_id=update.message.chat_id, text= f"{lang[userlang]['balance']['part-1']} {balance} {config.coin['ticker']}" ) else: ctx.bot.send_message( chat_id=update.message.chat_id, text=lang[userlang]['error']['general']['dm-only'])
def deposit(update, ctx): gettime = str(update.message.date).split() timetoconvert = gettime[0] + "T" + gettime[1] timestamp = strict_rfc3339.rfc3339_to_timestamp(timetoconvert) if timestart < int(timestamp): user = update.message.from_user userlang = db.getLang(user['id']) if update.message.chat.type == "private": if not db.checkUser(user["id"]): ctx.bot.send_message( chat_id=update.message.chat_id, text=lang[userlang]['error']['not-registered']) else: address = getAddress(user["id"]) ctx.bot.send_message( chat_id=update.message.chat_id, text= f"{lang[userlang]['deposit']['part-1']} <code>{address}</code>", parse_mode="HTML") else: ctx.bot.send_message( chat_id=update.message.chat_id, text=lang[userlang]['error']['general']['dm-only'])
def info(update, ctx): gettime = str(update.message.date).split() timetoconvert = gettime[0] + "T" + gettime[1] timestamp = strict_rfc3339.rfc3339_to_timestamp(timetoconvert) if timestart < int(timestamp): price = requests.get( f"https://api.coingecko.com/api/v3/simple/price?ids={config.coin['coin_name']}&vs_currencies=usd,btc" ).json() info = requests.get(f"{config.apiUrl}/info").json() btc = str(format(price["sugarchain"]["btc"], '.8f')) usd = str(price["sugarchain"]["usd"]) blocks = str(info['result']['blocks']) hash = formathash(int(info['result']['nethash'])) diff = str(info['result']['difficulty']) supply = str(format(convertToSugar(info['result']['supply']), '.8f')) ctx.bot.send_message(chat_id=update.message.chat_id, text=f""" Current block height: <code>{blocks}</code> Current network hashrate: <code>{hash}</code> Current network difficulty: <code>{diff}</code> Current circulating supply: <code>{supply}</code> SUGAR Current {config.coin['ticker']}/BTC price: {btc} BTC Current {config.coin['ticker']}/USD price: ${usd} """, parse_mode="HTML")
def tx_submit_rate(): """Process load testing log from stdin and print transaction submit rate in CSV format.""" buckets = collections.OrderedDict() for c, raw_line in enumerate(fileinput.input()): if c % 100 == 0: logging.debug('processing line %d', c) json_line = json.loads(raw_line) if json_line.get('msg') == 'submitting transaction': unix_ts = str( int(strict_rfc3339.rfc3339_to_timestamp( json_line['timestamp']))) if unix_ts not in buckets: buckets[unix_ts] = 1 else: buckets[unix_ts] += 1 rate_count = collections.defaultdict(lambda: 0) for rate in buckets.values(): rate_count[rate] += 1 w = csv.writer(sys.stdout) w.writerow(['txs per second (rate, 1s)', 'count']) for b in rate_count.items(): w.writerow(b)
def post_handler(self, data: dict, schema_order: list): response = make_response( request.headers, HTTPStatus.INTERNAL_SERVER_ERROR, json.dumps(http_message(HTTPStatus.INTERNAL_SERVER_ERROR))) retries = 0 while retries <= 3: try: body = EventHandler._order_data(data, schema_order) body['date'] = rfc3339_to_timestamp(body['date']) event_id = uuid1() self.es.create(index=self.index, id=event_id, body=body) body = self._generate_dict_body(body, event_id.int) response = make_response(request.headers, HTTPStatus.CREATED, json.dumps(body)) response.headers.add("Location", body["_links"]["self"]["href"]) break except ConflictError: # it's pretty impossible an uuid collision, but who knows... retries += 1 continue except Exception: # here is if something really bad happens, so let's exit and thow a 500 error break return response
def object(cls, *args): import strict_rfc3339 return datetime.datetime.utcfromtimestamp( strict_rfc3339.rfc3339_to_timestamp(*args) )
def execute(cls, stack: MichelsonStack, stdout: List[str], context: AbstractContext): res_type: MichelsonType literal: Type[MichelineLiteral] res_type, literal = cls.args # type: ignore if res_type.prim == 'AMOUNT': context.amount = literal.get_int() # type: ignore elif res_type.prim == 'BALANCE': context.balance = literal.get_int() # type: ignore elif res_type.prim == 'CHAIN_ID': context.chain_id = literal.get_string() # type: ignore elif res_type.prim == 'SENDER': context.sender = literal.get_string() # type: ignore elif res_type.prim == 'SOURCE': context.source = literal.get_string() # type: ignore elif res_type.prim == 'NOW': try: context.now = literal.get_int() # type: ignore # FIXME: Why does TypeError appear to be wrapped? except (TypeError, MichelsonRuntimeError): context.now = int( strict_rfc3339.rfc3339_to_timestamp( literal.get_string())) # type: ignore else: raise ValueError( f'Expected one of {cls.allowed_primitives}, got {res_type.prim}' ) return cls()
def process(self, element): logging.debug('AddTimestampToDict: %s %r' % (type(element), element)) return [ beam.window.TimestampedValue( element, strict_rfc3339.rfc3339_to_timestamp(element['timestamp'])) ]
def parse_date_time(date_string, date_time_string): if date_string: date_time = datetime.datetime.strptime(date_string, "%Y-%m-%d") else: timestamp = strict_rfc3339.rfc3339_to_timestamp(date_time_string) date_time = datetime.datetime.utcfromtimestamp(timestamp) return date_time
def make_clean_google_hours_dictionary(self, data): try: if data['items']: hours = [] for i in data['items']: hours.append(self._make_hour_obj( self._safe_grab(i, 'summary'), self._safe_grab(i, 'description'), True, strict_rfc3339.rfc3339_to_timestamp(i['start']['dateTime']), strict_rfc3339.rfc3339_to_timestamp(i['end']['dateTime']), self._safe_grab(i, 'timeZone'), )) return hours except Exception as e: #print "ERROR>>>>>>>> " + str(e) pass return [self._make_hour_obj('','nothing to show',False,'','','')]
def __init__(self, id=None, created=None, shards=None): self.id = id if created is not None: self.created = datetime.fromtimestamp( strict_rfc3339.rfc3339_to_timestamp(created)) else: self.created = None if shards is None: self.shards = [] else: self.shards = shards
def _estimate_time_received(receivers): sum_x, sum_x2, n = 0, 0, 0 for callsign in receivers: x = rfc3339_to_timestamp(receivers[callsign]['time_created']) sum_x += x sum_x2 += x * x n += 1 mean = sum_x / n std_dev = math.sqrt((sum_x2 / n) - (mean * mean)) new_sum_x, new_n = 0, 0 for callsign in receivers: x = rfc3339_to_timestamp(receivers[callsign]['time_created']) if abs(x - mean) > std_dev: continue new_sum_x += x new_n += 1 return new_sum_x / new_n if new_n != 0 else mean
def test_init(self): """Test Frame.__init__().""" kwargs = dict( created='2016-10-13T04:23:48.183Z', id='510b23e9f63a77d939a72a77', shards=[]) frame = Frame(**kwargs) assert frame.created == datetime.fromtimestamp( strict_rfc3339.rfc3339_to_timestamp( '2016-10-13T04:23:48.183Z')) assert frame.id == '510b23e9f63a77d939a72a77' assert frame.shards == []
def callsign_time_created_map(doc): """ View: ``listener_information/callsign_time_created`` Emits:: [callsign, time_created] -> null Times are UNIX timestamps (and therefore in UTC). Sorts by callsign. Useful to see a certain callsign's latest information. """ if doc['type'] == "listener_information": tc = rfc3339_to_timestamp(doc['time_created']) yield (doc['data']['callsign'], tc), None
def time_created_callsign_map(doc): """ View: ``listener_information/time_created_callsign`` Emits:: [time_created, callsign] -> null Times are UNIX timestamps (and therefore in UTC). Sorts by time created. Useful to see the latest listener information. """ if doc['type'] == "listener_information": tc = rfc3339_to_timestamp(doc['time_created']) yield (tc, doc['data']['callsign']), None
def __init__( self, token=None, bucket=None, operation=None, expires=None, encryptionKey=None ): self.id = token self.bucket = Bucket(id=bucket) self.operation = operation if expires is not None: self.expires = datetime.fromtimestamp( strict_rfc3339.rfc3339_to_timestamp(expires)) else: self.expires = None self.encryptionKey = encryptionKey
def launch_time_map(doc): """ View: ``payload_telemetry_stats/launch_time``` Emits:: launch_time -> {flight} for every approved flight, where {flight} is a flight-like doc containing only flight['name'] and flight['launch']['time'] """ if doc['type'] == 'flight' and doc['approved']: t = rfc3339_to_timestamp(doc['launch']['time']) d = {"name": doc['name'], "launch": {"time": doc['launch']['time']}} yield t, d
def process_changes(self, fcb_list, last_update): self.logger.info("id:%d Processing changes..." % self.ident) last_update = strict_rfc3339.rfc3339_to_timestamp(last_update) for element in fcb_list: element = file_object.FileObject(element) # Handle new files TODO Handle new files added to the creation_time = element.get_ctime() if creation_time > last_update: # Handle new file. self.logger.info("New file found: %s" % element.get_name()) self.file_tree_navigator.add_file_entry_id(element) else: # Handle changed file. self.logger.info("Changed file found: %s" % element.get_name()) self.file_tree_navigator.update_file_entry_id(element)
def name_time_created_map(doc): """ View: ``payload_configuration/name_time_created`` Emits:: [name, time_created] -> null In the key, ``time_created`` is emitted as a UNIX timestamp (seconds since epoch). Used to get a list of all current payload configurations, for display purposes or elsewhere where sorting by name is useful. """ if doc['type'] == "payload_configuration": created = rfc3339_to_timestamp(doc['time_created']) yield (doc['name'], created), None
def create(cls, info: dict) -> object: value = info.get('value') if not value: raise Exception('Missing signer token value for cloud asset') expired_at_str = info.get('expired_at') if not expired_at_str: raise Exception('Missing expiry time for cloud asset signer token') expire_timestamp = None try: expire_timestamp = rfc3339_to_timestamp(expired_at_str) except InvalidRFC3339Error as ex: raise Exception( 'Invalid format of expiry time for cloud asset signer token') return cls(value, datetime.fromtimestamp(expire_timestamp), info.get('extra'))
def get_results_for_plot(self, query): pts = self.client.query(query) results = list(pts.get_points()) retval = [] if len(results) > 0: keys = list(results[0].keys()) keys.remove('time') f = keys[0] for r in results: t = rfc3339_to_timestamp(r['time']) d = r[f] retval.append([t,d]) return retval
def launch_time_including_payloads_map(doc): """ View: ``flight/launch_time_including_payloads`` Emits:: [launch_time, flight_id, 0] -> [payload_configuration ids] [launch_time, flight_id, 1] -> {linked payload_configuration doc 1} [launch_time, flight_id, 1] -> {linked payload_configuration doc 2} ... Or, when a flight has no payloads:: [launch_time, flight_id, 0] -> null Times are all UNIX timestamps (and therefore in UTC). Sort by flight launch time. Only shows approved flights. Used by the calendar and other interface elements to show a list of upcoming flights. Query using ``startkey=[current_timestamp]`` to get all upcoming flights. Use ``include_docs=true`` to have the linked payload_configuration documents fetched and returned as the ``"doc"`` key for that row, otherwise the row's value will just contain an object that holds the linked ID. See the `CouchDB documentation <http://wiki.apache.org/couchdb/Introduction_to_CouchDB_views#Linked_documents>`_ for details on linked documents. """ if doc['type'] != "flight" or not doc['approved']: return flight_id = doc['_id'] lt = rfc3339_to_timestamp(doc['launch']['time']) if 'payloads' in doc: yield (lt, flight_id, 0), doc['payloads'] for payload in doc['payloads']: yield (lt, flight_id, 1), {'_id': payload} else: yield (lt, flight_id, 0), None
def test_init(self): """Test Token.__init__().""" kwargs = dict( token='token', bucket='bucket_id', operation='operation', expires='2016-10-13T04:23:48.183Z', encryptionKey='key_id', ) token = Token(**kwargs) assert token.id == kwargs['token'] assert token.bucket == Bucket(id=kwargs['bucket']) assert token.operation == kwargs['operation'] assert token.expires == datetime.fromtimestamp( strict_rfc3339.rfc3339_to_timestamp( kwargs['expires'])) assert token.encryptionKey == kwargs['encryptionKey']
def time_uploaded_day_map(doc): """ View: ``payload_telemetry_stats/time_uploaded_day`` Emits:: (time_created // (3600 * 24)) -> 1 for every receiver of every payload_telemetry doc that belongs to a flight (not a testing payload). N.B.: reduce is "_sum" (Erlang) """ if not _is_flight_telemetry(doc): return for info in doc['receivers'].itervalues(): t = rfc3339_to_timestamp(info["time_created"]) yield int(t // (3600 * 24)), 1
def constructTimeLineItem(self,item,isHistory = False): """ Construct an element to be added to the timeline """ isDir = False altName = item['id'] hasHistory = False if isHistory: displayDate = item['modifiedDate'] if "lastModifyingUserName" in item: title = item['lastModifyingUserName'] else: title = item['id'] trashed = str(False) else: displayDate = item['createdDate'] title = item['title'] trashed = str(item['labels']['trashed']) #check if the file has history if item['mimeType'] != "application/vnd.google-apps.folder": fd = self.db.getFileDownload(self.t,altName) fh = self.db.getHistoryForFile(fd) if len(fh) > 0: hasHistory = True if item['mimeType'] == "application/vnd.google-apps.folder": isDir = True altName = "" # date dateTuple = list(time.gmtime(strict_rfc3339.rfc3339_to_timestamp(displayDate)))[:6] #month -1 because javascript Date goes from 0-11 dateTuple[1] = dateTuple[1] - 1 date = ",".join(map(str,dateTuple)) jStr = '{"timeStr":"'+displayDate+'"}' return {'title': title,'time':date,'isDir':str(isDir),'trashed':trashed,'altName': altName,'params':jStr,'hasHistory':hasHistory}
def test_init(self): """Test Contact.__init__().""" kwargs = dict( address='api.storj.io', port=8443, nodeID='32033d2dc11b877df4b1caefbffba06495ae6b18', lastSeen='2016-05-24T15:16:01.139Z', protocol='0.7.0', userAgent='4.0.3' ) contact = Contact(**kwargs) assert contact.address == kwargs['address'] assert contact.port == kwargs['port'] assert contact.nodeID == kwargs['nodeID'] assert contact.lastSeen == datetime.fromtimestamp( strict_rfc3339.rfc3339_to_timestamp(kwargs['lastSeen'])) assert contact.protocol == kwargs['protocol'] assert contact.userAgent == kwargs['userAgent']
def metadataSearch(self,searchType,searchEmail,searchFile,searchGivenName,filterType,mimeType,startDate,endDate): """ Search through metadata """ searchItem = list() startDateTs = float(getTimestamp(startDate)) endDateTs = float(getTimestamp(endDate)) for i in self.metadata: creationTs = strict_rfc3339.rfc3339_to_timestamp(i['createdDate']) #check temporal period if creationTs >= startDateTs and creationTs <= endDateTs: prunedRes = self.metadataSearchType(i,searchType,searchEmail,searchFile,searchGivenName) if prunedRes != None: #now apply filters filteredRes = self.metadataSearchFilters(filterType,prunedRes,mimeType) if filteredRes != None: searchItem.append(filteredRes) return searchItem
def test_init(self): """Test Bucket.__init__().""" kwargs = dict( created='2016-10-13T04:23:48.183Z', id='510b23e9f63a77d939a72a77', name='integration-20161013_042347', pubkeys=[], status='Active', storage=0, transfer=0, user='******') bucket = Bucket(**kwargs) assert bucket.created == datetime.fromtimestamp( strict_rfc3339.rfc3339_to_timestamp( '2016-10-13T04:23:48.183Z')) assert bucket.id == '510b23e9f63a77d939a72a77' assert bucket.name == 'integration-20161013_042347' assert bucket.pubkeys == [] assert bucket.status == 'Active' assert bucket.storage == 0 assert bucket.transfer == 0 assert bucket.user == '*****@*****.**'
def callsign_time_created_index_map(doc): """ View: ``payload_configuration/callsign_time_created_index`` Emits:: [callsign, time_created, 1] -> [metadata, sentence 1] [callsign, time_created, 2] -> [metadata, sentence 2] ... [callsign, time_created, n] -> [metadata, sentence n] Where ``metadata`` is:: { "name": doc.name, "time_created": doc.time_created (original string), "metadata": doc.metadata (if present in doc) } (In other words, one row per sentence in this document). In the key, ``time_created`` is emitted as a UNIX timestamp (seconds since epoch). Useful to obtain configuration documents for a given callsign if it can't be found via upcoming flights, for example parsing test telemetry or selecting a sentence to copy when making a new document. """ if doc['type'] == "payload_configuration": if 'sentences' in doc: created = rfc3339_to_timestamp(doc['time_created']) for n, sentence in enumerate(doc['sentences']): m = {"name": doc["name"], "time_created": doc["time_created"]} if "metadata" in doc: m["metadata"] = doc["metadata"] yield (sentence['callsign'], created, n), (m, sentence)
def __init__( self, id=None, name=None, status=None, user=None, created=None, storage=None, transfer=None, pubkeys=None, publicPermissions=None, encryptionKey=None): self.id = id self.name = name self.status = status self.user = user self.storage = storage self.transfer = transfer self.pubkeys = pubkeys self.publicPermissions = publicPermissions self.encryptionKey = encryptionKey # self.files = FileManager(bucket_id=self.id) # self.pubkeys = BucketKeyManager( # bucket=self, authorized_public_keys=self.pubkeys) # self.tokens = TokenManager(bucket_id=self.id) if created is not None: self.created = datetime.fromtimestamp( strict_rfc3339.rfc3339_to_timestamp(created)) else: self.created = None