def get_current_whales( self, num_whales=30 ): #by default, fetch only 30 whales off the book either way whales = [] for index, bid_whale in self._bid_whales.items(True): if index == num_whales: break else: whales.append({ 'price': Decimal128(bid_whale.get_price()), 'volume': Decimal128(bid_whale.get_volume()), 'id': bid_whale.get_id(), }) for index, ask_whale in self._ask_whales.items(): if index == num_whales: break else: whales.append({ 'price': Decimal128(ask_whale.get_price()), 'volume': Decimal128(ask_whale.get_volume()), 'id': ask_whale.get_id(), }) whales_frame = pd.DataFrame(whales) return whales_frame
def positive_sample(): return { FIELD_RESULT: POSITIVE_RESULT_VALUE, FIELD_ROOT_SAMPLE_ID: "MCM001", FIELD_CH1_CQ: Decimal128("5.12345678"), FIELD_CH2_CQ: Decimal128("6.12345678"), FIELD_CH3_CQ: Decimal128("7.12345678"), }
def test_v2_is_positive_returns_false_all_ct_values_greater_than_30(): identifier = FilteredPositiveIdentifierV2() sample = positive_sample() sample[FIELD_CH1_CQ] = Decimal128("40.12345678") sample[FIELD_CH2_CQ] = Decimal128("41.12345678") sample[FIELD_CH3_CQ] = Decimal128("42.12345678") assert identifier.is_positive(sample) is False
def main(): mongo_client = MongoClient(MDB_CONNECTION) db = mongo_client[MDB_DATABASE] my_collection = db[MDB_COLLECTION] print('Begin generating txns documents.') print('Number of documents to generate: ' + str(NUM_DOCS)) for index in range(int(NUM_DOCS)): fake_timestamp = fake.date_between(start_date='-1y', end_date='today') txn_types = ['deposit', 'withdrawal'] txns = random.choice(txn_types) my_txn_document = { "customerId": fake.ssn(), "name": fake.name(), "address": fake.street_address(), "city": fake.city(), "state": fake.state(), "postalCode": fake.postcode(), "email": fake.email(), "lastLocation": { "type": "Point", "coordinates": [Decimal128(fake.longitude()), Decimal128(fake.latitude())] }, "txnType": txns, "txnAmount": random.randint(0, 10000), "txnDate": datetime.datetime(fake_timestamp.year, fake_timestamp.month, fake_timestamp.day) } # Print example doc on first doc creation if index == 1: print('Example Document') print(my_txn_document) # Indicate how many docs inserted if index % 100 == 0: print('Docs inserted: ' + str(index)) my_collection.insert_one(my_txn_document)
async def set_escrow_sum(message: types.Message, offer: EscrowOffer): """Set sum and ask for fee payment agreement.""" try: offer_sum = money(message.text) except MoneyValueError as exception: await tg.send_message(message.chat.id, str(exception)) return order = await database.orders.find_one({"_id": offer.order}) order_sum = order.get(offer.sum_currency) if order_sum and offer_sum > order_sum.to_decimal(): await tg.send_message(message.chat.id, i18n("exceeded_order_sum")) return update_dict = {offer.sum_currency: Decimal128(offer_sum)} new_currency = "sell" if offer.sum_currency == "sum_buy" else "buy" update_dict[f"sum_{new_currency}"] = Decimal128( normalize(offer_sum * order[f"price_{new_currency}"].to_decimal())) escrow_sum = update_dict[f"sum_{offer.type}"] escrow_fee = Decimal(config.ESCROW_FEE_PERCENTS) / Decimal("100") update_dict["sum_fee_up"] = Decimal128( normalize(escrow_sum.to_decimal() * (Decimal("1") + escrow_fee))) update_dict["sum_fee_down"] = Decimal128( normalize(escrow_sum.to_decimal() * (Decimal("1") - escrow_fee))) offer = replace(offer, **update_dict) # type: ignore if offer.sum_currency == offer.type: insured = await get_insurance(offer) update_dict["insured"] = Decimal128(insured) if offer_sum > insured: keyboard = InlineKeyboardMarkup() keyboard.add( InlineKeyboardButton( i18n("continue"), callback_data=f"accept_insurance {offer._id}"), InlineKeyboardButton(i18n("cancel"), callback_data=f"init_cancel {offer._id}"), ) answer = i18n("exceeded_insurance {amount} {currency}").format( amount=insured, currency=offer.escrow) answer += "\n" + i18n("exceeded_insurance_options") await tg.send_message(message.chat.id, answer, reply_markup=keyboard) else: await ask_fee(message.from_user.id, message.chat.id, offer) await offer.update_document({ "$set": update_dict, "$unset": { "sum_currency": True } })
def main(): print('NUM DOCS TO GENERATE: ' + str(NUM_DOCS)) mongo_client = MongoClient(MDB_CONNECTION) db = mongo_client[MDB_DATABASE] my_collection = db[MDB_COLLECTION] for index in range(int(NUM_DOCS)): # Define Subscription Doc my_document = { "ApplicationID": fake.uuid4(), "UserID": fake.uuid4(), "Type": fake.random_int(1, 10), "Address": "MyDeviceAddr", "Units": fake.random_int(1, 10), "Culture": { "LanguageCode": fake.language_code(), "CountryCode": fake.country_code() }, "Target": { "IsFollowMe": True, "LocationInfo": { "Point": { "type": "Point", "coordinates": [ Decimal128(fake.longitude()), Decimal128(fake.latitude()) ] }, "PostalKey": fake.postcode(), "CountryCode": fake.country_code(), "TimeZone": fake.timezone(), "DmaID": "524", "CityID": fake.uuid4(), "CountyID": "GAC057", "PollenID": "ATL", "TideID": "", "ZoneID": "GAZ021", "AdminDistrict": "GA:US" }, "SavedLocationType": fake.random_int(1, 10) }, "Schedule": { "IsActive": False, "Days": None, "Hours": None, "TimeZone": "" }, "CreatedOn": datetime.datetime.now() } my_collection.insert_one(my_document)
def test_update_inc_decimal128(monty_update, mongo_update): docs = [ {"a": Decimal128("1.5")} ] spec = {"$inc": {"a": 1}} monty_c = monty_update(docs, spec) mongo_c = mongo_update(docs, spec) assert next(mongo_c) == next(monty_c) monty_c.rewind() assert next(monty_c) == {"a": Decimal128("2.5")}
def test_update_mul_decimal128(monty_update, mongo_update): docs = [ {"a": Decimal128("1.5")} ] spec = {"$mul": {"a": 2}} monty_c = monty_update(docs, spec) mongo_c = mongo_update(docs, spec) assert next(mongo_c) == next(monty_c) monty_c.rewind() assert next(monty_c) == {"a": Decimal128("3.0")}
def get_last_operation(self, email): finded = self.operations_collection.find_one({"email": email}, sort=[("date", pymongo.DESCENDING) ]) if (finded != None): return Operation(finded['email'], finded['value'], finded['date'], finded['type'], finded['balance']) else: return Operation(email, Decimal128('0'), datetime.timestamp(datetime.now()), 'Initial balance', Decimal128('0'))
def decimal128(s): """ 浮点数或者字符串转化为decimal128 :param s: :return: """ if isinstance(s, Decimal128): money = s else: try: money = Decimal128(s) except (ValueError, InvalidOperation): money = Decimal128("0") return Decimal128(money.to_decimal().quantize(Decimal("0.00")))
def withdraw(self, email, value): last_op = self.get_last_operation(email) new_balance = Decimal128(last_op.balance.to_decimal() - Decimal128(value).to_decimal()) wit = { 'email': email, 'value': Decimal128(value), 'date': datetime.timestamp(datetime.now()), 'type': 'Withdraw', 'balance': new_balance } insert = self.insert_operation(wit) return 'withdraw successful'
def main(): mongo_client = MongoClient(MDB_CONNECTION) db = mongo_client[MDB_DATABASE] my_collection = db[MDB_COLLECTION] print('Delete existing documents.') result = my_collection.delete_many({}) print('Num docs deleted: ' + str(result.deleted_count)) print('Begin generating IOT documents.') print('Number of documents to generate: ' + str(NUM_DOCS)) for index in range(int(NUM_DOCS)): # create timestamp fake_timestamp = fake.date_this_year() # Define IoT Document my_iot_document = { "username": fake.user_name(), "remote_ipv4": fake.ipv4(), "httpMethod": fake.http_method(), "hostName": fake.hostname(), "portNum": fake.port_number(), "location": { "type": "Point", "coordinates": [Decimal128(fake.longitude()), Decimal128(fake.latitude())] }, "dateAccessed": datetime.datetime(fake_timestamp.year, fake_timestamp.month, fake_timestamp.day) } if index == 1: print('Example Document') print(my_iot_document) # Indicate how many docs inserted every 100 iterations if index % 100 == 0: print('Docs inserted: ' + str(index)) my_collection.insert_one(my_iot_document)
def insert_record(self, name, nric, age, income, cpf, addr, lease_id, img_str, detected_income=None, img_highlight=None, verified=False, renewable=False, verify_fail=None, renew_fail=None): record = { 'person': { 'nric': nric, 'first_name': name, 'age': age, 'income': { 'declared': Decimal128(income), 'cpf': Decimal128(cpf) } }, 'property': { 'address': addr, 'lease_id': lease_id }, 'date': datetime.datetime.utcnow(), 'original': img_str, 'verified': verified, 'renewable': renewable } if img_highlight is not None: record['annotated'] = img_highlight if detected_income is not None: record['detected_income'] = Decimal128(detected_income) if verified == False and verify_fail is not None: record['verify_fail'] = verify_fail if renewable == False and renew_fail is not None: record['renew_fail'] = renew_fail self.payslip_col.insert_one(record)
def get_real_time_price(symbol: Union[str, List[str]] = None): if symbol is None: return [] if isinstance(symbol, str): symbol = [symbol, ] res = requests.get(GetStockData.URL, params={ 'function': 'BATCH_STOCK_QUOTES', 'symbols': ','.join(symbol), 'apikey': Utils.get_env('ALPHAVANTAG_API_KEY') }) j = res.json() #type: dict ret_list = [] if 'Stock Quotes' in j: tz = j['Meta Data']['3. Time Zone'] for info in j['Stock Quotes']: tmp_dict = {'timestamp': arrow.get(info['4. timestamp']).replace(tzinfo=tz).datetime, 'symbol': info['1. symbol'], 'price': Decimal128(info['2. price'])} try: tmp_dict['volume'] = Int64(info['3. volume']) except (BSONError, ValueError): tmp_dict['volume'] = Int64(0) ret_list.append(tmp_dict) else: print(arrow.utcnow().isoformat()) print(json.dumps(j, indent=1)) return ret_list
def info(self): return { "firstname": self.firstname, "lastname": self.lastname, "username": self.username, "email": self.email, "password": self.password, "fitness": self.fitness, "weight": Decimal128(self.weight), "goalweight": Decimal128(self.goalweight), "goal": self.goal, "history": [], #"email_confirmation_sent_on" : self.email_confirmation_sent_on, "email_confirmed": self.email_confirmed, "email_confirmed_on": self.email_confirmed_on }
def test_sort_18(monty_sort, mongo_sort): docs = [ {"a": ["x", True]}, {"a": None}, {"a": []}, {"a": [5, []]}, {"a": {"s": 7}}, {"a": {"s": [9]}}, {"a": {"s": 10}}, {"a": 6}, {"a": 4}, {"a": [5, None]}, {"a": [5, [1]]}, {"a": [Decimal128("4.5"), Binary(b"0")]}, {"a": [{"s": 5}, False]}, {"a": [{"s": 9}]}, {"a": [True, "y"]}, {"a": []}, ] sort = [("a", -1)] monty_c = monty_sort(docs, sort) mongo_c = mongo_sort(docs, sort) for i in range(len(docs)): assert next(mongo_c)["_id"] == next(monty_c)["_id"]
def add_product(): """ A view to return the add product page, add the product to the database and update the relevant category's brands list in the database. """ if request.method == "POST": """ Gets the details entered into the form and convert them into a dictionary, converts the price to the decimal 128 data type and adds the default rating values to the dictionary. Decimal128 method is from https://pymongo.readthedocs.io/en/stable/api/bson/decimal128.html """ product = request.form.to_dict() product['price'] = Decimal128(product['price']) product['overall_rating'] = 0 product['performance_rating'] = 0 product['usability_rating'] = 0 product['price_rating'] = 0 product['quality_rating'] = 0 product['five_stars'] = 0 product['four_stars'] = 0 product['three_stars'] = 0 product['two-stars'] = 0 product['one_star'] = 0 """ Deletes any products from the dictionary which have a value of an empty string. Code is from https://stackoverflow.com/questions/6307394/ removing-dictionary-entries-with-no-values-python """ keys = list(product.keys()) for key in keys: if product[key] == "": del product[key] """ Adds the product details to the database and Adds the brand to the relevant brands list in the database. Add to set method is from https://docs.mongodb.com/manual/reference/operator/update/addToSet/ """ mongo.db.products.insert_one(product) mongo.db.categories.update_one( {"name": product['category']}, {"$addToSet": { "brands": product['brand'] }}) """ Code for message categories is from https://flask.palletsprojects.com/ en/1.1.x/patterns/flashing/ """ flash("Product Successfully Added", "success") return redirect(url_for('product_management')) # Get a list of categories from the database categories = mongo.db.categories.find() return render_template('add_product.html', page_title='Add Product', categories=categories)
def test_special(self): dnan = Decimal('NaN') dnnan = Decimal('-NaN') dsnan = Decimal('sNaN') dnsnan = Decimal('-sNaN') dnan128 = Decimal128(dnan) dnnan128 = Decimal128(dnnan) dsnan128 = Decimal128(dsnan) dnsnan128 = Decimal128(dnsnan) # Due to the comparison rules for decimal.Decimal we have to # compare strings. self.assertEqual(str(dnan), str(dnan128.to_decimal())) self.assertEqual(str(dnnan), str(dnnan128.to_decimal())) self.assertEqual(str(dsnan), str(dsnan128.to_decimal())) self.assertEqual(str(dnsnan), str(dnsnan128.to_decimal()))
def object_hook(dct, json_options=DEFAULT_JSON_OPTIONS): if "$oid" in dct: return ObjectId(str(dct["$oid"])) if "$ref" in dct: return DBRef(dct["$ref"], dct["$id"], dct.get("$db", None)) if "$date" in dct: return _get_date(dct, json_options) if "$regex" in dct: flags = 0 # PyMongo always adds $options but some other tools may not. for opt in dct.get("$options", ""): flags |= _RE_OPT_TABLE.get(opt, 0) return Regex(dct["$regex"], flags) if "$minKey" in dct: return MinKey() if "$maxKey" in dct: return MaxKey() if "$binary" in dct: return _get_binary(dct, json_options) if "$code" in dct: return Code(dct["$code"], dct.get("$scope")) if "$uuid" in dct: return uuid.UUID(dct["$uuid"]) if "$undefined" in dct: return None if "$numberLong" in dct: return Int64(dct["$numberLong"]) if "$timestamp" in dct: tsp = dct["$timestamp"] return Timestamp(tsp["t"], tsp["i"]) if "$numberDecimal" in dct: return Decimal128(dct["$numberDecimal"]) return dct
def cart(): orders = [] if 'order_products' not in session: session['order_products'] = [] else: for item in session['order_products']: orders.append({ "product": list(get_product(item["id"]))[0], "number": item["number"] }) D128_CTX = create_decimal128_context() with decimal.localcontext(D128_CTX): total_price = sum([ order["product"]['price'].to_decimal() * Decimal128(order['number']).to_decimal() for order in orders ]) if "order_products" not in session: session["order_products"] = [] num = len(session["order_products"]) return render_template('blog/cart.html', orders=orders, total_price=total_price, badge_num=num)
def add_game(): if "appid" in request.form and "name" in request.form: new_game = { "appid": int(request.form["appid"]), "name": request.form["name"], "release_date": datetime(2010, 12, 3), "english": "1", "developer": [], "publisher": [], "platforms": [], "required_age": 0, "categories": [], "genres": [], "steamspy_tags": [], "achievements": 0, "positive_ratings": 1111, "negative_ratings": 1111, "average_playtime": 1111, "median_playtime": 1111, "owners": "test", "price": Decimal128('7.19'), "comments": [] } # Get object id, if needed, not necessary since appid unique indexing new_game_id = games.insert_one(new_game) new_game_link = "http://localhost:5000/api/v1.0/games/" + \ request.form["appid"] return make_response(jsonify({"url": new_game_link}), 201) else: return make_response(jsonify({"error": "Missing form data"}), 404)
def _parse_canonical_decimal128(doc: Any) -> Decimal128: """Decode a JSON decimal128 to bson.decimal128.Decimal128.""" d_str = doc["$numberDecimal"] if len(doc) != 1: raise TypeError("Bad $numberDecimal, extra field(s): %s" % (doc, )) if not isinstance(d_str, str): raise TypeError("$numberDecimal must be string: %s" % (doc, )) return Decimal128(d_str)
def convert_value(v): if v is None: return ('n', False) if type(v) is not str: return ('s', False) return Decimal128(Decimal(v)), True
def test_validate_bson_decimal_valid_bson_decimal(): class MyModel(Model): field: Decimal128 value = Decimal128("3.152345596") instance = MyModel(field=value) assert isinstance(instance.field, Decimal128) assert instance.field == value
class EncodeDecimalsTestCase: @pytest.mark.parametrize( "data, expected", [ pytest.param( {"money_amount": Decimal("13.37")}, {"money_amount": Decimal128("13.37")}, id="simple_dict", ), pytest.param( [{ "money_amount": Decimal("13.37") }], [{ "money_amount": Decimal128("13.37") }], id="simple_list", ), pytest.param( {"author": { "money_amount": Decimal("13.37") }}, {"author": { "money_amount": Decimal128("13.37") }}, id="nested", ), pytest.param( { "title": "test", "contributors": [{ "money_amount": Decimal("13.37") }], }, { "title": "test", "contributors": [{ "money_amount": Decimal128("13.37") }], }, id="list_in_nested", ), ], ) async def test__convert_decimals(self, data, expected): assert mongodb_encoders._convert_decimals(data) == expected
def to_mongo(self, value): if isinstance(value, Decimal128): return value try: return Decimal128(decimal.Decimal(value)) except decimal.DecimalException as exc: raise ValidationError('Cannot convert value %r to Decimal128: %s' % (value, exc.__class__.__name__))
def _parse_canonical_decimal128(doc): """Decode a JSON decimal128 to bson.decimal128.Decimal128.""" d_str = doc['$numberDecimal'] if len(doc) != 1: raise TypeError('Bad $numberDecimal, extra field(s): %s' % (doc, )) if not isinstance(d_str, string_type): raise TypeError('$numberDecimal must be string: %s' % (doc, )) return Decimal128(d_str)
def add(self): user = { "firstname": self.firstname, "lastname": self.lastname, "username": self.username, "email": self.email, "password": self.password, "fitness": self.fitness, "weight": Decimal128(self.weight), "goalweight": Decimal128(self.goalweight), "goal": self.goal, "history": [], #"email_confirmation_sent_on" : self.email_confirmation_sent_on, "email_confirmed": self.email_confirmed, "email_confirmed_on": self.email_confirmed_on } DB.insert("users", user)
def numeric_type(wgt, val): if isinstance(value, (Decimal128, _cmp_decimal)): if isinstance(val, _cmp_decimal): val = val._dec if val in _decimal128_NaN_ls: val = Decimal128('NaN') # MongoDB does not sort them return (wgt, _cmp_decimal(val)) else: return (wgt, val)
def test_sort_5(monty_sort, mongo_sort): docs = [{"a": 0}, {"a": 1.1}, {"a": Int64(2)}, {"a": Decimal128("3.3")}] sort = [("a", -1)] monty_c = monty_sort(docs, sort) mongo_c = mongo_sort(docs, sort) for i in range(len(docs)): assert next(mongo_c)["_id"] == next(monty_c)["_id"]
def test_round_trip(self): if not client_context.version.at_least(3, 3, 6): raise unittest.SkipTest( 'Round trip test requires MongoDB >= 3.3.6') coll = client_context.client.pymongo_test.test coll.drop() dec128 = Decimal128.from_bid( b'\x00@cR\xbf\xc6\x01\x00\x00\x00\x00\x00\x00\x00\x1c0') coll.insert_one({'dec128': dec128}) doc = coll.find_one({'dec128': dec128}) self.assertIsNotNone(doc) self.assertEqual(doc['dec128'], dec128)
def test_pickle(self): dec128 = Decimal128.from_bid( b'\x00@cR\xbf\xc6\x01\x00\x00\x00\x00\x00\x00\x00\x1c0') for protocol in range(pickle.HIGHEST_PROTOCOL + 1): pkl = pickle.dumps(dec128, protocol=protocol) self.assertEqual(dec128, pickle.loads(pkl))
def _get_decimal128(data, position, dummy0, dummy1, dummy2): """Decode a BSON decimal128 to bson.decimal128.Decimal128.""" end = position + 16 return Decimal128.from_bid(data[position:end]), end