Exemple #1
0
    def test_decimal(self):
        # Default behavior: Decimal is preserved
        obj = decimal.Decimal(0.5)
        as_json = jsonpickle.dumps(obj)
        clone = jsonpickle.loads(as_json)
        self.assertTrue(isinstance(clone, decimal.Decimal))
        self.assertEqual(obj, clone)

        # Custom behavior: we want to use simplejson's Decimal support.
        jsonpickle.set_encoder_options('simplejson',
                                       use_decimal=True, sort_keys=True)

        jsonpickle.set_decoder_options('simplejson',
                                       use_decimal=True)

        # use_decimal mode allows Decimal objects to pass-through to simplejson.
        # The end result is we get a simple '0.5' value as our json string.
        as_json = jsonpickle.dumps(obj, unpicklable=True, use_decimal=True)
        self.assertEqual(as_json, '0.5')
        # But when loading we get back a Decimal.
        clone = jsonpickle.loads(as_json)
        self.assertTrue(isinstance(clone, decimal.Decimal))

        # side-effect: floats become decimals too!
        obj = 0.5
        as_json = jsonpickle.dumps(obj)
        clone = jsonpickle.loads(as_json)
        self.assertTrue(isinstance(clone, decimal.Decimal))
 def initFromJSON(self, jsSrc):
     if self.source is "FILE":
         self.ldd = jsonpickle.loads(jsSrc.read())
     if self.source is "NETWORK":
         self.ldd = jsonpickle.loads(jsSrc)
     self.newCal = Calendar(self.ldd["myUID"])
     evtList = list(map(lambda cvt: genCalEvt(cvt), self.ldd["caltxts"]))
     for evt in evtList:
         self.newCal.addEntry(evt)
     return self.newCal
Exemple #3
0
def _main():
    arguments_json_path = sys.argv[1]
    with open(arguments_json_path) as f:
        arguments = jsonpickle.loads(f.read())

    # arguments_json_path is a temporary file created by the parent process.
    # so we remove it here
    os.remove(arguments_json_path)

    task_id = arguments['task_id']
    port = arguments['port']
    messenger = _Messenger(task_id=task_id, port=port)
    messenger.started()

    operation_mapping = arguments['operation_mapping']
    operation_inputs = arguments['operation_inputs']
    context_dict = arguments['context']

    # This is required for the instrumentation work properly.
    # See docstring of `remove_mutable_association_listener` for further details
    storage_type.remove_mutable_association_listener()

    with instrumentation.track_changes() as instrument:
        try:
            ctx = serialization.operation_context_from_dict(context_dict)
            _patch_session(ctx=ctx, messenger=messenger, instrument=instrument)
            task_func = imports.load_attribute(operation_mapping)
            aria.install_aria_extensions()
            for decorate in process_executor.decorate():
                task_func = decorate(task_func)
            task_func(ctx=ctx, **operation_inputs)
            messenger.succeeded(tracked_changes=instrument.tracked_changes)
        except BaseException as e:
            messenger.failed(exception=e,
                             tracked_changes=instrument.tracked_changes)
Exemple #4
0
    def test_sqlalchemy_with_dynamic_table(self):
        """Test creating a table dynamically, per #180"""

        if self.should_skip:
            return self.skip('sqlalchemy is not installed')

        meta = sqa.MetaData()
        expect = sqa.Table(
            'test', meta,
            sqa.Column('id', sqa.Integer()),
            sqa.Column('text', sqa.Text()))

        jsonstr = jsonpickle.dumps(expect)
        actual = jsonpickle.loads(jsonstr)

        self.assertEqual(expect.__class__, actual.__class__)
        self.assertEqual(expect.name, actual.name)
        # These must be unique instances
        self.assertNotEqual(expect.metadata, actual.metadata)
        # Columns names must exactly match
        self.assertEqual(sorted(expect.columns.keys()),
                         sorted(actual.columns.keys()))
        # As should the types
        self.assertEqual(expect.c.id.name, actual.c.id.name)
        self.assertEqual(expect.c.id.type.__class__,
                         actual.c.id.type.__class__)
        self.assertEqual(expect.c.text.name, actual.c.text.name)
        self.assertEqual(expect.c.text.type.__class__,
                         actual.c.text.type.__class__)
Exemple #5
0
    def get(self, request):
        # 1.插入Order表中数据
        # 获取请求参数
        import uuid, datetime
        # print(request.GET.get('payway'))
        # print request.GET.get('address', '')
        date = {
            "out_trade_num": uuid.uuid4().get_hex(),
            "order_num": datetime.datetime.today().strftime('%Y%m%d%H%M%S'),
            "payway": request.GET.get('payway'),
            "address": Address.objects.get(id=request.GET.get('address', '')),
            "user": request.session.get('user', ''),
        }
        orderObj = Order.objects.create(**date)

        # 2.插入OrderItem表中数据
        cartitems = jsonpickle.loads(request.GET.get('cartitems'))

        orderItemList = [OrderItem.objects.create(order=orderObj, **item) for item in cartitems if item]

        totalPrice = request.GET.get('totalPrice')[1:]

        # 获取扫码支付请求参数
        params = alipay.direct_pay(subject='京东超市',
                                   out_trade_no=orderObj.out_trade_num,
                                   total_amount=str(totalPrice))

        # 获取扫码支付的请求地址
        url = alipay.gateway + "?" + params
        return redirect(url)
Exemple #6
0
def mainfunc(request):
    user = request.session.get('user','')

    if user:
        user = jsonpickle.loads(user)

    return {"info":user}
Exemple #7
0
    def lineReceived(self, line):
        try:
            line = line.decode()
            log.debug(f"render | out | {line}")
            response = jsonpickle.loads(line)
        except Exception as e:
            response = {}

        #: Special case for startup
        response_id = response.get('id')
        if response_id == 'window_id':
            self.window_id = response['result']
            self.restarts = 0  # Clear the restart count
        elif response_id == 'render_error':
            self.errors = response['error']['message']
        elif response_id == 'render_ok':
            self.errors = ""
        elif response_id == 'capture_output':
            # Script output capture it
            self.output = response['result'].split("\n")
        elif response_id is not None:
            # Lookup the deferred object that should be stored for this id
            # when it is called and invoke the callback or errback based on the
            # result
            d = self._responses.get(response_id)
            if d is not None:
                del self._responses[response_id]
                error = response.get('error')
                if error is not None:
                    d.errback(error)
                else:
                    d.callback(response.get('result'))
        else:
            # Append to output
            self.output.append(line)
Exemple #8
0
 def test_timedelta(self):
     if self.should_skip:
         return self.skip('bson is not installed')
     td = datetime.timedelta(-1, 68400)
     serialized = jsonpickle.dumps(td)
     restored = jsonpickle.loads(serialized)
     self.assertEqual(restored, td)
Exemple #9
0
 def test_nested_objects(self):
     if self.should_skip:
         return self.skip('bson is not installed')
     o = Object(99)
     serialized = jsonpickle.dumps(o)
     restored = jsonpickle.loads(serialized)
     self.assertEqual(restored.offset, datetime.timedelta(99))
Exemple #10
0
 def test_FixedOffsetSerializable(self):
     if self.should_skip:
         return self.skip('bson is not installed')
     fo = bson.tz_util.FixedOffset(-60 * 5, 'EST')
     serialized = jsonpickle.dumps(fo)
     restored = jsonpickle.loads(serialized)
     self.assertEqual(vars(restored), vars(fo))
Exemple #11
0
 def set_state(self, state):
     state = jsonpickle.loads(state.decode('utf-8'))
     for key, value in six.iteritems(state):
         try:
             self._objects[key].set_state(value)
         except KeyError:
             system_log.warn('core object state for {} ignored'.format(key))
Exemple #12
0
	def update(self):
		if os.path.isfile(self.path + '/job.json'):
			with open(self.path + '/job.json') as f:
				out_job = jsonpickle.loads(f.read())
			self.__dict__.update(out_job.__dict__)
		else:
			self.save()
Exemple #13
0
 def load_servers(self):
     resp = urllib2.urlopen("http://qsrdk.daili666api.com/ip/?tid=558571735483018&num=100&delay=3&category=2&protocol=http&foreign=only&format=json")
     servers = jsonpickle.loads(resp.read())
     for sver in servers:
         server  = ProxyServer(sver['host'],sver['port'])
         print("load " + str(server) + " into manager")
         self.load_server(server)
Exemple #14
0
    def from_dict(cls, node_dict):
        """
        Creates a node from a dict representation
        :param node_dict: dict
        :return: datamodel.base.node.Node
        """
        # import classes, so we can instantiate them at need
        import robograph.datamodel

        # retrieve the class object so we can instantiate the node
        klass = eval(node_dict['class'])
        node = klass(name=node_dict['name'])

        # now retrieve the parameters
        parameters = dict()
        for p in node_dict['params']:
            parameters[p] = node_dict['params'][p]

            # are we deserializing a pickled function?
            if isinstance(node_dict['params'][p], unicode):
                if "py/bytes" in node_dict['params'][p]:
                    parameters[p] = cloudpickle.loads(jsonpickle.loads(node_dict['params'][p]))

        node.input(parameters)
        node.set_output_label(node_dict['output_label'])
        return node
Exemple #15
0
    def get(self, requset):
        # 获取请求参数
        import uuid, datetime
        data = {
            'out_trade_num': uuid.uuid4().hex,
            'order_num': datetime.datetime.today().strftime('%Y%m%d%H%M%S'),
            'pyway': requset.GET.get('payway'),
            'address': Address.objects.get(id=requset.GET.get('address', '')),
            'user': requset.session.get('user', '')
        }

        # 1.插入order表数据
        orderObj = Order.objects.create(**data)
        # 2.插入item表数据
        cartItems = jsonpickle.loads(requset.GET.get('cartitems'))

        orderItemList = [
            OrderItem.objects.create(order=orderObj, **item)
            for item in cartItems if item
        ]

        totalPriceId = requset.GET.get('totalPriceId')[1:]

        # 获取扫码支付页面
        params = alipay.direct_pay(subject='京东超市',
                                   out_trade_no=orderObj.out_trade_num,
                                   total_amount=str(totalPriceId))

        # 拼接请求地址
        url = alipay.gateway + '?' + params
        return HttpResponseRedirect(url)
 def test_simple(self):
     print self.segment.byte_bounds_offset(), len(self.segment)
     r2 = self.segment.rawdata[100:400]
     s2 = DefaultSegment(r2)
     print s2.byte_bounds_offset(), len(s2), s2.__getstate__()
     r3 = s2.rawdata[100:200]
     s3 = DefaultSegment(r3)
     print s3.byte_bounds_offset(), len(s3), s3.__getstate__()
     order = list(reversed(range(700, 800)))
     r4 = self.segment.rawdata.get_indexed(order)
     s4 = DefaultSegment(r4)
     print s4.byte_bounds_offset(), len(s4), s4.__getstate__()
     
     slist = [s2, s3, s4]
     for s in slist:
         print s
     j = jsonpickle.dumps(slist)
     print j
     
     slist2 = jsonpickle.loads(j)
     print slist2
     for s in slist2:
         s.reconstruct_raw(self.segment.rawdata)
         print s
     
     for orig, rebuilt in zip(slist, slist2):
         print "orig", orig.data[:]
         print "rebuilt", rebuilt.data[:]
         assert np.array_equal(orig[:], rebuilt[:])
Exemple #17
0
 def set_state(self, state):
     state = jsonpickle.loads(state.decode('utf-8'))
     for key, value in six.iteritems(state):
         try:
             self._objects[key].set_state(value)
         except KeyError:
             system_log.warn('core object state for {} ignored'.format(key))
 def test_FixedOffsetSerializable(self):
     if self.should_skip:
         return self.skip('bson is not installed')
     fo = bson.tz_util.FixedOffset(-60*5, 'EST')
     serialized = jsonpickle.dumps(fo)
     restored = jsonpickle.loads(serialized)
     self.assertEqual(vars(restored), vars(fo))
Exemple #19
0
 def __getitem__(self, key: str) -> Optional[Any]:
     GET_ITEM = f'SELECT value FROM "{self.tablename}" WHERE key = (?)'
     item = self.con.execute(GET_ITEM, (key, )).fetchone()
     if item:
         return jsonpickle.loads(item[0])
     else:
         return None
Exemple #20
0
    def get(self, request):
        # 获取请求参数
        cartitems = request.GET.get('cartitems', '')
        # 将json格式字符串转换成python对象
        cartitemsList = jsonpickle.loads("[" + cartitems + "]")

        # 将python对象转换成cartitems对象列表
        cartitemObjList = [
            getCartManger(request).get_cartitems(**item)
            for item in cartitemsList if item
        ]

        # 1.获取用户默认收货地址
        address = request.session.get('user').address_set.get(isdefault=True)
        # 2.获取支付总金额
        totalPrice = 0
        for cm in cartitemObjList:
            totalPrice += cm.getTotalPrice()

        return render(
            request, 'order.html', {
                'cartitemList': cartitemObjList,
                'address': address,
                'totalPrice': totalPrice
            })
Exemple #21
0
 def sign_in_user(self, email, password):
     try:
         user = auth.sign_in_with_email_and_password(email, password)
         auth.get_account_info(user['idToken'])
         user_id = auth.get_account_info(
             user['idToken'])['users'][0]['localId']
         private_key = list(
             db.child('users').child(user_id).get(
                 user['idToken']).val().values())[0]
         self.privateKey = private_key
         self.address = self.address_gen()
         self.publicKey = keys.get_public_key(self.privateKey, curve.P256)
         return True
     except Exception as e:
         print(jsonpickle.loads(e.args[1])['error']['message'])
         return jsonpickle.loads(e.args[1])['error']['message']
Exemple #22
0
def getLoginUserInfo(request):
    """获取登录用户对象信息"""
    user = request.session.get('user', '')
    if user:
        user = jsonpickle.loads(user)

    return {'loginUser': user}
 def test_timedelta(self):
     if self.should_skip:
         return self.skip('bson is not installed')
     td = datetime.timedelta(-1, 68400)
     serialized = jsonpickle.dumps(td)
     restored = jsonpickle.loads(serialized)
     self.assertEqual(restored, td)
 def test_nested_objects(self):
     if self.should_skip:
         return self.skip('bson is not installed')
     o = Object(99)
     serialized = jsonpickle.dumps(o)
     restored = jsonpickle.loads(serialized)
     self.assertEqual(restored.offset, datetime.timedelta(99))
    def test_attach_nic_to_net_success(self):
        """

        :return:
        """

        import jsonpickle

        mock_client = Mock()
        test_nova_instance_service.novaclient.Client = Mock(return_value=mock_client)

        mock_instance = Mock()

        mock_iface_attach_result = Mock()
        mock_instance.interface_attach = Mock(return_value=mock_iface_attach_result)

        expected_test_mac = 'test_mac_address'
        expected_port_id = 'test_port_id'
        expected_ip_address = 'test_ip_address'
        mock_result_dict = {'mac_addr': expected_test_mac,
                            'port_id': expected_port_id,
                            'fixed_ips': [{'ip_address': expected_ip_address}]}
        mock_iface_attach_result.to_dict = Mock(return_value=mock_result_dict)
        self.instance_service.get_instance_from_instance_id = Mock(return_value=mock_instance)

        result = self.instance_service.attach_nic_to_net(openstack_session=self.openstack_session,
                                                         net_id='test_net_id',
                                                         instance_id='test_instance_id',
                                                         logger=self.mock_logger)
        expected_result_dict = {'ip_address': expected_ip_address,
                                'port_id': expected_port_id,
                                'mac_address': expected_test_mac}

        self.assertEqual(jsonpickle.loads(result), expected_result_dict)
def callback(ch, method, properties, body):
    try:
        print("{} - RabbitMQ message received - begin processing".format(hostname), file=sys.stderr)
        rabbitMQChannel.basic_publish(exchange='logs', routing_key=debug, body="RabbitMQ message received - begin processing")
        print (jsonpickle.loads(body))
        fileName = jsonpickle.loads(body)['fileName']
        imgHash = jsonpickle.loads(body)['imgHash']
        imgData = pickle.loads(codecs.decode(jsonpickle.loads(body)['imgData'].encode(), "base64"))

        redisNameToHash.set(fileName, imgHash)      # filename -> hash DB1
        print("Entry added to DB1 - redisNameToHash: <{}><{}>".format(fileName, imgHash), file=sys.stderr)
        rabbitMQChannel.basic_publish(exchange='logs', routing_key=info, body="Entry added to DB1 - redisNameToHash")
        rabbitMQChannel.basic_publish(exchange='logs', routing_key=debug, body="DB1: <{}><{}>".format(fileName, imgHash))
        redisHashToName.sadd(imgHash, fileName)     # hash -> [filename] DB2
        print("Entry added to DB2 - redisHashToName: <{}><{}>".format(imgHash, redisHashToName.smembers(imgHash)), file=sys.stderr)
        rabbitMQChannel.basic_publish(exchange='logs', routing_key=info, body="Entry added to DB2 - redisHashToName")
        rabbitMQChannel.basic_publish(exchange='logs', routing_key=debug, body="DB2: <{}><{}>".format(imgHash, redisHashToName.smembers(imgHash)))

        # Load the received image file
        img = face_recognition.load_image_file(imgData)
        # Get face encodings for any faces in the received image
        unknown_face_encodings = face_recognition.face_encodings(img)

        if len(unknown_face_encodings) > 0:
            for i in unknown_face_encodings:
                redisHashToFaceRec.sadd(imgHash, jsonpickle.dumps(i))     # hash -> [face encodings] DB3
                print("Entry added to DB3 - redisHashToFaceRec: <{}><{}>".format(imgHash, redisHashToFaceRec.smembers(imgHash)), file=sys.stderr)
                rabbitMQChannel.basic_publish(exchange='logs', routing_key=info, body="Entry added to DB3 - redisHashToFaceRec")
                rabbitMQChannel.basic_publish(exchange='logs', routing_key=debug, body="DB3: <{}><{}>".format(imgHash, redisHashToFaceRec.smembers(imgHash)))
                for key in redisHashToFaceRec.scan_iter():
                    known_face_encodings = [jsonpickle.loads(j) for j in redisHashToFaceRec.smembers(key)]
                    if any(face_recognition.compare_faces(known_face_encodings, i)):
                        redisHashToHashSet.sadd(imgHash, key)       # hash -> [hashes]  DB4
                        redisHashToHashSet.sadd(key, imgHash)       # hash -> [hashes]  DB4
                        print("Entries added to DB4 - redisHashToHashSet: <{}><{}>, <{}><{}>".format(imgHash, redisHashToHashSet.smembers(imgHash), key, redisHashToHashSet.smembers(key)), file=sys.stderr)
                        rabbitMQChannel.basic_publish(exchange='logs', routing_key=info, body="Entries added to DB4 - redisHashToHashSet")
                        rabbitMQChannel.basic_publish(exchange='logs', routing_key=debug, body="DB4: <{}><{}>, <{}><{}>".format(imgHash, redisHashToHashSet.smembers(imgHash), key, redisHashToHashSet.smembers(key)))

        print("{} - RabbitMQ message processed and acknowledged".format(hostname), file=sys.stderr)
        rabbitMQChannel.basic_publish(exchange='logs', routing_key=debug, body="RabbitMQ message processed and acknowledged")
        ch.basic_ack(delivery_tag=method.delivery_tag)
    
    except Exception as e:
        #send negative ack
        print ("Error in callback: {}".format(e))
        rabbitMQChannel.basic_publish(exchange='logs', routing_key=debug, body="Error in callback: {}".format(e))
        channel.basic_nack(delivery_tag=method.delivery_tag)
Exemple #27
0
    def post(self,request):
        # 判断用户是否登录
        if 'user' not in request.session:
            return redirect('/user/login/')
        user = jsonpickle.loads(request.session.get('user'))

        # 获取 sku_ids
        sku_ids = request.POST.getlist('sku_ids')

        # 判断 sku_ids 是否存在
        if not sku_ids:
            return redirect('/cart/info/')

        # 连接 redis
        con = get_redis_connection('default')
        cart_key = 'cart_%d'%user.id

        skus = []
        total_count = 0
        total_price = 0

        for sku_id in sku_ids:
            # 获取商品信息
            sku = GoodsSKU.objects.get(id=sku_id)
            # 获取商品数量
            count = con.hget(cart_key,sku_id)
            # 获取商品小计
            amount = int(count) * sku.price
            # 动态添加商品数量
            sku.count = int(count)
            # 动态添加商品小计
            sku.amount = amount
            # 追加
            skus.append(sku)
            # 获取商品总数量
            total_count += int(count)
            # 获取商品总价格
            total_price += amount
        # 获取商品运费
        transit_price = 10
        # 获取商品实付价格
        total_pay = total_price + transit_price
        # 获取地址信息
        address = Address.objects.filter(user=user)
        # 处理sku_ids的数据类型
        sku_ids = ','.join(sku_ids)

        # 组织上下文
        context = {
            'sku_ids':sku_ids,
            'skus':skus,
            'total_count':total_count,
            'total_prece':total_price,
            'transit_price':transit_price,
            'total_pay':total_pay,
            'address':address
        }

        return render(request,'place_order.html',context)
Exemple #28
0
    def post(self,request):
        # 判断用户是否登录
        if 'user' not in request.session:
            return JsonResponse({'res': 0, 'errmsg': '请先登录'})
        user = jsonpickle.loads(request.session.get('user'))

        # 获取参数
        order_id = request.POST.get('order_id')
        # 校验数据
        if not order_id:
            return JsonResponse({'res': 1, 'errmsg': '无效的订单ID'})
        # 查看订单是否存在
        try:
            order = OrderInfo.objects.get(user=user, pay_method=3, order_status=1, order_id=order_id)
        except OrderInfo.DoesNotExist:
            return JsonResponse({'res': 2, 'errmsg': '订单无效'})

        # 使用python.SDK 连接支付宝接口
        # 初始化
        # 业务处理:条用python.sdk条用支付宝的支付接口
        # 初始化
        alipay = AliPay(
            appid="2016093000634740",  # APPID 支付宝沙箱
            app_notify_url=None,  # 默认回调url
            # 应用私钥
            app_private_key_path=os.path.join(os.path.dirname(os.path.abspath(__file__)), 'app_private_key.pem'),
            # 支付宝公钥
            alipay_public_key_path=os.path.join(os.path.dirname(os.path.abspath(__file__)),
                                                'alipay_public_key.pem'),
            sign_type='RSA2',  # RSA 或者 RSA2
            debug=True  # 默认False
        )

        # 调用支付宝订单查询接口
        while True:
            response = alipay.api_alipay_trade_query(order_id)

            code = response.get('code')
            trade_status = response.get('trade_status')
            if code == '10000' and trade_status == 'TRADE_SUCCESS':
                # 支付成功
                # 获取支付宝交易号
                trade_on = response.get('trade_no')
                # 更新订单状态
                order.trade_on = trade_on
                order.order_status = 4  # 待评价
                order.save()
                # 返回结果
                return JsonResponse({'res': 3, 'message': '支付成功'})

            elif code == '40004' or code == '10000' and trade_status == 'WAIT_BUYER_PAY':
                # 业务处理失败,可能一会就能成功
                # 等待买家付款
                import time
                time.sleep(3)
                continue
            else:
                # 支付出错
                return JsonResponse({'res': 4, 'errmsg': '支付失败'})
Exemple #29
0
    def line_received(self, line):
        """ Called when a newline is received

        Parameters
        ----------
        line: String
            The data

        """
        if not line:
            return
        try:
            request = jsonpickle.loads(line)
        except Exception as e:
            return self.send_message({
                'id': None,
                'error': {
                    'code': -32700,
                    'message': f'Parse error: "{line}"'
                }
            })

        request_id = request.get('id')
        method = request.get('method')
        if method is None:
            return self.send_message({
                "id": request_id,
                "error": {
                    'code': -32600,
                    'message': "Invalid request"
                }
            })

        handler = getattr(self, 'handle_{}'.format(method), None)
        if handler is None:
            msg = f"Method '{method}' not found"
            return self.send_message({
                "id": request_id,
                'error': {
                    'code': -32601,
                    'message': msg
                }
            })

        try:
            params = request.get('params', [])
            if isinstance(params, dict):
                result = handler(**params)
            else:
                result = handler(*params)
            return self.send_message({'id': request_id, 'result': result})
        except Exception as e:
            return self.send_message({
                "id": request_id,
                'error': {
                    'code': -32500,
                    'message': traceback.format_exc()
                }
            })
Exemple #30
0
    def post(self, request):
        aname = request.POST.get('user-name')
        phone = request.POST.get('user-phone')
        address = request.POST.get('detailarea')
        user_obj = jsonpickle.loads(request.session.get('user'))

        if Address.objects.filter(account_id=user_obj.id):
            isdel = 0
        else:
            isdel = 1
        account = jsonpickle.loads(request.session.get('user'))
        Address.objects.create(aname=aname,
                               phonenum=phone,
                               addr=address,
                               account=account,
                               isdefault=isdel)
        return redirect('addr')
Exemple #31
0
 def test_datetime_with_fixed_offset(self):
     if self.should_skip:
         return self.skip('bson is not installed')
     fo = bson.tz_util.FixedOffset(-60 * 5, 'EST')
     dt = datetime.datetime.now().replace(tzinfo=fo)
     serialized = jsonpickle.dumps(dt)
     restored = jsonpickle.loads(serialized)
     self.assertEqual(restored, dt)
Exemple #32
0
def messageFromJSON(JSON):
    partlog = []
    content = jsonpickle.loads(JSON)
    for userevt in content['partLog']:

        partlog.append(UserEventfromJSON(userevt))

    return Message(content['sourceID'],content['destID'],content['tt'],partlog)
Exemple #33
0
    def update(self,goodsid,colorid,sizeid,step,*args,**kwargs):

        key = self.__get_key(goodsid,colorid,sizeid)
        if key in self.session[self.cart_name]:
            cartitem = jsonpickle.loads(self.session[self.cart_name][key])
            cartitem.count = int(str(cartitem.count))+int(step)
        else:
            raise Exception('SessionManager中的update出错了')
Exemple #34
0
 def _res(self, r):
     try:
         return jsonpickle.loads(r.json())
     except:
         try:
             return r.json()
         except:
             return r.content.decode()
Exemple #35
0
 def __init__(self, cache_file=None):
     self.cache_file = cache_file or str(
         Path.home()) + '/.sciqlopcache/db.json'
     if os.path.exists(self.cache_file):
         with open(self.cache_file, 'r') as f:
             self._data = jsonpickle.loads(f.read())
     else:
         self._data = {}
def _recv_message(connection):
    # Retrieving the length of the msg to come.
    def _unpack(conn):
        return struct.unpack(_INT_FMT, _recv_bytes(conn, _INT_SIZE))[0]

    msg_metadata_len = _unpack(connection)
    msg = _recv_bytes(connection, msg_metadata_len)
    return jsonpickle.loads(msg)
Exemple #37
0
 def get(self, request):
     #获取当前登录用户下的收货地址信息
     # 获取当前登录用户对象
     userstr = request.session.get('user', '')
     if userstr:
         user = jsonpickle.loads(userstr)
     addr_list = user.address_set.all()
     return render(request, 'address.html', {'addr_list': addr_list})
Exemple #38
0
    def test_get_encoded_attachments_file(self):
        class TestNotification(EmailNotification):
            attachments = [File(open('tests/python.jpeg', 'rb'))]

        attachments = jsonpickle.loads(
            TestNotification()._get_encoded_attachments())
        self.assertEqual(attachments[0][0], 'tests/python.jpeg')
        self.assertEqual(attachments[0][2], 'image/jpeg')
Exemple #39
0
def main(request):
    #从session中获取用户名
    user=request.session.get('user','')
    if user:
        u=jsonpickle.loads(user)
    uname=u.uname

    return HttpResponse(u'欢迎%s登陆成功'%uname)
Exemple #40
0
def load_covenant_from_file(path):
    import jsonpickle

    with open(path, "r") as f:
        covenant = jsonpickle.loads(f.read())

    print(f"Covenant successfully loaded from {path}")
    return covenant
Exemple #41
0
 def load():
     try:
         with open(DEFAULT_PATH, "r") as file:
             obj = jsonpickle.loads(file.read())
             return obj
     except IOError as e:
         raise IOError(
             "Could not load any password from previous sessions.")
Exemple #42
0
    def test_datetime_with_fixed_offset_incremental(self):
        """Test creating an Unpickler and incrementally encoding"""
        if self.should_skip:
            return self.skip('bson is not installed')
        obj = datetime.datetime(
            2019, 1, 29, 18, 9, 8, 826000, tzinfo=bson.tz_util.utc)
        doc = jsonpickle.dumps(obj)

        # Restore the json using a custom unpickler context.
        unpickler = jsonpickle.unpickler.Unpickler()
        jsonpickle.loads(doc, context=unpickler)

        # Incrementally restore using the same context
        clone = json.loads(
            doc, object_hook=lambda x: unpickler.restore(x, reset=False))

        self.assertEqual(obj.tzinfo.__reduce__(), clone.tzinfo.__reduce__())
 def check_for_saved_bot():
     if os.path.exists(BotFilesManager.bot_resources_file_name):
         file = open(BotFilesManager.bot_resources_file_name)
         data = file.read()
         file.close()
         return jsonpickle.loads(data)
     else:
         return None
 def test_datetime_with_fixed_offset(self):
     if self.should_skip:
         return self.skip('bson is not installed')
     fo = bson.tz_util.FixedOffset(-60*5, 'EST')
     dt = datetime.datetime.now().replace(tzinfo=fo)
     serialized = jsonpickle.dumps(dt)
     restored = jsonpickle.loads(serialized)
     self.assertEqual(restored, dt)
 def test_next_runfolder(self):
     path = self._create_ready_runfolder()
     self.assertTrue(self._exists(path))
     response = self.get("./runfolders/next", expect=200)
     response_json = jsonpickle.loads(response.text)
     self.assertEqual(response_json["path"], path)
     self.assertEqual(response_json["state"], State.READY)
     # Remove the path created, so it does not interfere with other tests
     shutil.rmtree(path)
    def state_list(self):
        """
        :rtype: list(WatchState)
        """
        state_entry_list = self._state_table().all()
        if not state_entry_list:
            return []

        return jsonpickle.loads(state_entry_list[0]['pickle'])
    def _get_sandbox_details(self, sandbox_id):
        url = 'http://{hostname}:{api_port}/api/v1/sandboxes/{sandbox_id}' \
            .format(hostname=self.hostname, api_port=self.api_port, sandbox_id=sandbox_id)
        response = requests.get(url, auth=self.token_auth)
        self._ensure_response_success(response)
        response_text = self.python_version_compatible_response_text(response)

        state = jsonpickle.loads(response_text)
        return state
Exemple #48
0
def from_json(value):
    """
    Convert json to an object. This will only work for objects which were converted to json with unpickable=True.
    In all other cases, the result will be a dict instead.

    :param value: the value to convert to an object
    :return: the object or dict
    """
    return jsonpickle.loads(value)
Exemple #49
0
    def deserialize_arguments(args_serialized):
        """
        Provides a method to deserialize arguments provided by the endpoint client.

        :param args_serialized: arguments and keyword arguments serialized by the client
        :type args_serialized: str
        :return: Deserialized representation of the arguments
        :rtype: object
        """
        return jsonpickle.loads(args_serialized)
 def test_orchestration_save_should_save_to_complex_path(self):
     request = """
     {
         "custom_params": {
             "folder_path" : "tftp://10.0.0.1/folder1/some folder/and Another Directory"
             }
     }"""
     handler = self._get_handler()
     json_string = handler.orchestration_save(custom_params=request)
     print json_string
     validate(jsonpickle.loads(json_string), schema=get_schema())
    def fromJSON(self, text):
        result = jsonpickle.loads(text)

        result["startTS"] = DateTimeDecoder(result["startTS"])
        result["endTS"] = DateTimeDecoder(result["endTS"])
        result["insertTime"] = DateTimeDecoder(result["insertTime"])
        # bt1 = DateTimeDecoder(result["eventRange"][0])
        # bt2 = DateTimeDecoder(result["eventRange"][1])
        # result["eventRange"] = busyT(start=bt1, end=bt2)
        self.__dict__ = result
        return result
 def test_orchestration_save_should_save_to_simple_ftp_path(self):
     request = """
     {
         "custom_params": {
             "folder_path" : "ftp://*****:*****@10.0.0.1/"
             }
     }"""
     handler = self._get_handler()
     json_string = handler.orchestration_save(custom_params=request)
     print json_string
     validate(jsonpickle.loads(json_string), schema=get_schema())
Exemple #53
0
    def test_roundtrip(self):
        if self.should_skip:
            return self.skip('ecdsa module is not installed')

        message = 'test'.encode('utf-8')
        key_pair = self.SigningKey.generate(curve=self.NIST384p)
        sig = key_pair.sign(message)

        serialized = jsonpickle.dumps(key_pair.get_verifying_key())
        restored = jsonpickle.loads(serialized)
        self.assertTrue(restored.verify(sig, message))
Exemple #54
0
 def set_state(self, state):
     value = jsonpickle.loads(state.decode('utf-8'))
     for v in value['open_orders']:
         o = Order()
         o.set_state(v)
         account = self._env.get_account(o.order_book_id)
         self._open_orders.append((account, o))
     for v in value['delayed_orders']:
         o = Order()
         o.set_state(v)
         account = self._env.get_account(o.order_book_id)
         self._delayed_orders.append((account, o))
    def test_get_action_result_info_removevlan(self):

        test_action_dict = {'customActionAttributes': [{'attributeName': 'VM_UUID', 'attributeValue': 'test-vm-uuid'}],
                            'connectorAttributes' : [{'attributeName': 'Interface',
                                                      'attributeValue': '{"ip_address":"test_ip" , \
                                                      "mac_address": "test_mac","port_id":"test_port_id"}'}]}
        test_action_obj = DeployDataHolder(test_action_dict)

        print test_action_obj.connectorAttributes[0].attributeValue
        print jsonpickle.loads(test_action_obj.connectorAttributes[0].attributeValue)

        mock_deployed_app_resource_name = 'test app name'
        mock_actionid = 'test-actionid'

        result = self.connectivity_service.get_action_resource_info(deployed_app_resource_name=mock_deployed_app_resource_name,
                                                                    actionid=mock_actionid,
                                                                    action=test_action_obj)
        self.assertEqual(result.vm_uuid, 'test-vm-uuid')
        self.assertEqual(result.iface_ip, 'test_ip')
        self.assertEqual(result.interface_port_id, 'test_port_id')
        self.assertTrue(result.interface_mac, 'test_mac')
 def test_orchestration_save_should_save_default_config(self):
     request = """
     {
         "custom_params": {
             "folder_path" : "tftp://10.0.0.1/folder1",
             "vrf_management_name": "network-1"
             }
     }"""
     handler = self._get_handler()
     json_string = handler.orchestration_save(custom_params=request)
     print json_string
     validate(jsonpickle.loads(json_string), schema=get_schema())
 def test_orchestration_save_get_invalid_folder_path(self):
     request = """
     {
         "custom_params": {
             "configuration_type" : "Running",
             "folder_path" : "tftp://10.0.0.1///folder1//folder 2//folder 5",
             "vrf_management_name": "network-1"
             }
     }"""
     handler = self._get_handler()
     json_string = handler.orchestration_save(custom_params=request)
     print json_string
     validate(jsonpickle.loads(json_string), schema=get_schema())
    def test_serializes_to_schema(self):
        created_date = datetime.datetime.now()
        identifier = created_date.strftime('%y_%m_%d %H_%M_%S_%f')

        orchestration_saved_artifact = OrchestrationSavedArtifact('test_type', identifier)

        saved_artifacts_info = OrchestrationSavedArtifactInfo(
            resource_name="some_resource",
            created_date=created_date,
            restore_rules=OrchestrationRestoreRules(requires_same_resource=True),
            saved_artifact=orchestration_saved_artifact)

        orchestration_save_result = OrchestrationSaveResult(saved_artifacts_info)
        json_string = jsonpickle.encode(orchestration_save_result, unpicklable=False)
        validate(jsonpickle.loads(json_string), schema=self.get_schema())
Exemple #59
0
def UserEventfromJSON( JSON):
    content = jsonpickle.loads(JSON)
    calvt = model.genCalEvt(content['calevt'])

    eventTypeInt = content['eventType']

    eventTypeNew = EventType.unassigned
    if eventTypeInt is 1:
        eventTypeNew = EventType.insert
    elif eventTypeInt is 2:
        eventTypeNew = EventType.delete

    print(calvt)
    event = UserEvent(eventTypeNew,content['Tiii'],calvt,content['uid'])
    return event
Exemple #60
0
 def __dispach_method(self, method_name, *args, **kwargs):
     stdin, stdout, stderr = self.ssh_client.exec_command('python3 sshrpc_endpoint.py')
     stdin.write(method_name + '\n')
     client_args = [list(args), kwargs]
     client_args = jsonpickle.dumps(client_args)
     stdin.write(client_args + '\n')
     output = stdout.read()
     # print(output)
     result = jsonpickle.loads(output.decode("utf-8"))
     if result.get('failure'):
         tb = result.get('traceback')
         print('---- Traceback received from remote endpoint ----\n')
         print(tb)
         print('\n----\n')
         raise RemoteMethodException(result.get('exception_class'))
     self.ssh_client.close()
     return result.get('result')