Python parser.parse函数代码示例

def callback(request, auth_name):
    if auth_name == 'dropbox':
        post_dict = parser.parse(request.POST.urlencode())
        code = str(post_dict['code'])
        userid = str(post_dict['userid'])
        json_response = dbauth.handleCallback(userid, code, request)
        return HttpResponse(json_response)

    if auth_name == 'google':
        post_dict = parser.parse(request.POST.urlencode())
        code = str(post_dict['code'])
        json_response = gauth.handleCallback(code, request)
        return HttpResponse(json_response)

    return HttpResponse('Invalid URL')

def trainamodel(request):
    data = {}
    try:
        post_dict = parser.parse(request.POST.urlencode())

        socketid = post_dict['socketid']
        log_to_terminal('Beginning training a new model', post_dict['socketid'])

        old_save_dir = conf.PIC_DIR
        folder_name = str(socketid)
        save_dir = os.path.join(conf.PIC_DIR, folder_name)
        train_dir = os.path.join(save_dir, 'train')
        test_dir = os.path.join(save_dir, 'test')
        util_dir = os.path.join(save_dir, 'util')

        if not os.path.exists(os.path.join(old_save_dir, folder_name)):
            raise Exception('No training images has been provided for this job.')

        trainModel(save_dir, post_dict['socketid'])

        data['info'] = 'completed'
        response = JSONResponse(data, {}, response_mimetype(request))
        response['Content-Disposition'] = 'inline; filename=files.json'
        log_to_terminal('Finished training your model with the new categories. Now, upload some test images to test this model. ', socketid)
        return response
    except Exception as e:
        data['error'] = str(traceback.format_exc())
        log_to_terminal(str(traceback.format_exc()), socketid)
        response = JSONResponse(data, {}, response_mimetype(request))
        response['Content-Disposition'] = 'inline; filename=files.json'
        return response

def delete_equipment(request):
    if request.method == 'POST':
        post = parser.parse(request.POST.urlencode())
        e = Equipment.objects.get(pk=int(post['equip']))
        print 'vai deletar aqui'
        #e.delete()
    return HttpResponse("ok", mimetype='application/json')

	def get(self, request, **kwargs):
		arguments = parser.parse(request.GET.urlencode())

		take = arguments.get('take', 10)
		skip = arguments.get('skip', 0)
		total = skip+take
		filter_arg = dict()
		sort_arg = list()
		filter_logic = 'and'

		if(arguments.has_key('filter') and arguments['filter'].has_key('filters')):
			filter_arg = self._build_filters(arguments['filter']['filters'], filter_arg)
			filter_logic = arguments['filter']['logic'].upper()

		if(arguments.has_key('group')):
			sort_arg = self._build_sorts(arguments['group'], sort_arg)

		if(arguments.has_key('sort')):
			sort_arg = self._build_sorts(arguments['sort'], sort_arg)

		output = dict()

		try:
			filters = Q(**filter_arg)
			filters.connector = filter_logic
			items = self.model.objects.filter(filters).order_by(*sort_arg)
			if(self.distinct):
				items = items.distinct()
			self.queryset = items[skip:total]
			output = {'result':1, 'count':items.count(), 'payload':self.get_queryset()}
		except FieldError:
			output = {'result':0, 'error':'Invalid request. Tried to filter or sort using invalid field.'}

		return response_json(request, output)

    def parse(self, stream, media_type=None, parser_context=None):
        import urllib
        from querystring_parser import parser
        from django.conf import settings

        encoding = parser_context.get("encoding", settings.DEFAULT_CHARSET)
        return parser.parse(stream.read(), unquote=True, encoding=encoding)

def geocoder(request):
    
    parsed_dict = parser.parse(request.POST.urlencode())
                    
    r = Geocode(parsed_dict['addresses'])
        
    return HttpResponse(r, mimetype='application/json')

def page_report(request, report, fmt='csv', conf=None):
    get_dict = parser.parse(request.GET.urlencode())
    objs = get_queryset(request, report, get_dict)[:100]
    if objs.count()==0:
        return HttpResponse('No Data')

#    if(isinstance(objs, list)):
#        conn = DictListConnector(objs, expand_obs=True)
#    else:
#        conn = DjangoQuerySetConnector(objs)

#    if report in REPORTS:
#        cls = REPORTS[report]
#        if cls.Meta.fields:
#            conn.header = cls.Meta.fields
#        elif cls.Meta.exclude:
#            conn.header = Set(conn.header) - Set(cls.Meta.exclude)
#        elif cls.Meta.sequence:
#            conn.header = Set(cls.Meta.sequence) | Set(conn.header)

    tf = tempfile.NamedTemporaryFile()
    fn = tf.name
    fp = open(fn, "w+")
    DataProvider.WriteData(objs, fmt, fn)
    fp.close()
    response = StreamingHttpResponse(open(fn), content_type='text/csv') 
    response['Content-Disposition'] = 'attachment; filename=' + report  + '.csv'
    return response

def set_led_values(device_name):
    check_device(device_name)
    dev = devices[device_name]
    args = parser.parse(request.get_data())
    for led, value in args['led'].items():
        dev.set_pwm(int(led), int(value))
    return create_response({'result': 'ok'})

def decaf_train(request):
    post_dict = parser.parse(request.POST.urlencode())
    try:
        if 'urls' not in post_dict:
            data = {'error': 'NoFileSelected'}
        else:
            data = {'info': 'ProcessingImages'}

            # Download these images. Run Feature Extraction. Post results.
            uuid, image_path = downloadAndSaveImages(post_dict['urls'], post_dict['socketid'])

            output_path = os.path.join(image_path, 'results')
            if not os.path.exists(output_path):
                os.makedirs(output_path)
            decaf_wrapper_local(image_path, output_path, post_dict['socketid'], os.path.join(conf.PIC_URL, uuid))
            log_to_terminal('Processing Images Now', post_dict['socketid'])

        response = JSONResponse(data, {}, response_mimetype(request))
        response['Content-Disposition'] = 'inline; filename=files.json'
        return response
    except:
        data = {'result': str(traceback.format_exc())}
        response = JSONResponse(data, {}, response_mimetype(request))
        response['Content-Disposition'] = 'inline; filename=files.json'
        return response

def show_deploy(request, cluster_id):


    #get_dict = parser.parse( unicode(request.GET.urlencode()).encode("utf-8") )
    #return uncache_response(HttpResponse(json.dumps(get_dict, indent=2), content_type="text/plain"))
    #return uncache_response(HttpResponse( get_dict['password'] , content_type="text/plain"))

    context = {}
    password = None

    try:
        cluster = ClusterDefinition.objects.get( id=cluster_id )

        if cluster.encryption_checksum != '':
            try:
                get_dict = parser.parse( unicode(request.GET.urlencode()).encode("utf-8") )
                password = get_dict['password']
                cluster.decrypt(password)
            except Exception as e:
                #messages.error(request, "The password provided is wrong: %s" % e)
                messages.error(request, "The password provided is wrong")
                return render(request, "cluster/deploy.html", {})

    except ClusterDefinition.DoesNotExist, Http404:
        messages.error(request, 'Cluster does not exist')
        return render(request, "cluster/deploy.html", {})

    def get(self):
        args = parser.parse(request.query_string)
        options = {
            "start": args.get("start", 0),
            "limit": args.get("length", 10),
            "search": args.get("search", {}).get("value"),
        }

        columns = []
        for i in range(len(args["columns"])):
            columns.append(args["columns"][i])

        order = []
        for i in range(len(args["order"])):
            column_id = args["order"][i]["column"]
            order.append({"column": columns[column_id]["data"], "dir": args["order"][i]["dir"]})
        options["order"] = order

        rows, total = self.get_queryset(**options)
        data = []
        for row in rows:
            row_data = {}
            for column in columns:
                callback = getattr(self, "process_%s" % column["data"], lambda row, val: val)
                val = getattr(row, column["data"], None)
                row_data[column["data"]] = callback(row, val)
            data.append(row_data)

        return jsonify(recordsTotal=total, recordsFiltered=total, data=data)

    def parse(self, stream, media_type=None, parser_context=None):
        from querystring_parser import parser
        from django.conf import settings

        encoding = parser_context.get('encoding', settings.DEFAULT_CHARSET)
        encoded_data = stream.read().decode(encoding)
        return parser.parse(encoded_data)

def get_bookmarks(request):
    #sync the client-side bookmarks with the server side bookmarks
    #update the server-side bookmarks and return the new list
    try:        
        bookmark_dict = parser.parse(request.POST.urlencode())['bookmarks']
    except:
        bookmark_dict = {}
    try:
        #loop through the list from the client
        #if user, bm_name, and bm_state match then skip 
        #otherwise, add to the db
        for key,bookmark in bookmark_dict.items():
            try:
                Bookmark.objects.get(user=request.user, name=bookmark['name'], url_hash=bookmark['hash'])
            except:
                new_bookmark = Bookmark(user=request.user, name=bookmark['name'], url_hash=bookmark['hash'])
                new_bookmark.save()
    
        #grab all bookmarks belonging to this user 
        #serialize bookmarks into 'name', 'hash' objects and return simplejson dump 
        content = []
        bookmark_list = Bookmark.objects.filter(user=request.user)
        for bookmark in bookmark_list:
            content.append({'name': bookmark.name, 'hash': bookmark.url_hash})
        return HttpResponse(simplejson.dumps(content), mimetype="application/json", status=200)
    except:
        return HttpResponse(status=304)

def _validate_for_save(request):
    """
    Validates the HttpRequest. It uses the forms defined in forms.py to
    check all the fields and runs some additional checks. It returns
    an HttpResponse instance if request is invalid and the dictionary of clean
    date otherwise.
    """
    data = parser.parse(request.POST.urlencode())
    clean_data = {}

    # Cluster section
    cluster_f = ClusterForm(data.get("cluster", {}))
    if not cluster_f.is_valid():
        for label, msg in cluster_f.errors_list:
            messages.error(request, "Cluster %s: %s" % (label, msg))
        return _show_cluster_def(request, data)
    clean_data["cluster"] = cluster_f.clean()

    # Check that contexts belong to user or is public
    for context_field_code in ["master_context_id", "worker_context_id"]:
        c = ContextDefinition.objects.get(
            id=clean_data["cluster"][context_field_code]
        )
        if not c.public and c.owner != request.user:
            messages.error(
                request,
                "Context with id '%s' is not public and does not belong to\
 you" % (c.id)
            )
            return _show_cluster_def(request, data)
        #if c.is_encrypted:
        #    messages.error(request, "Context '%s' is encrypted!" % (c.name))
        #    return _show_cluster_def(request, data)

    # elastiq section
    elastiq_f = ElastiqForm(data.get("elastiq", {}))
    if not elastiq_f.is_valid():
        for label, msg in elastiq_f.errors_list:
            messages.error(request, "elastiq %s: %s" % (label, msg))
        return _show_cluster_def(request, data)
    clean_data["elastiq"] = elastiq_f.clean()

    # EC2 section
    ec2_f = EC2Form(data.get("ec2", {}))
    if not ec2_f.is_valid():
        for label, msg in ec2_f.errors_list:
            messages.error(request, "EC2 %s: %s" % (label, msg))
        return _show_cluster_def(request, data)
    clean_data["ec2"] = ec2_f.clean()

    # Quota section
    quota_f = QuotaForm(data.get("quota", {}))
    if not quota_f.is_valid():
        for label, msg in quota_f.errors_list:
            messages.error(request, "Quota %s: %s" % (label, msg))
        return _show_cluster_def(request, data)
    clean_data["quota"] = quota_f.clean()

    return clean_data

 def update_cart(self):
     """
     Cart update form action: update quantities, remove marked for removal items
     """
     post_dict = parser.parse(self.request.POST.urlencode())
     self.request.cart.update_quantities(post_dict["item_quantity"])
     if "remove_item" in post_dict:
         self.request.cart.remove_items(list(post_dict["remove_item"]))