Python MultiDict.get方法代码示例

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import get [as 别名]
    def from_params(params: MultiDict, items: int) -> 'Page':
        # page, page-size, limit (deprecated)
        page = params.get('page', 1, int)
        limit = params.get('limit', 0, int)
        page_size = params.get('page-size', limit, int)

        return Page(page, page_size, items)

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import get [as 别名]
def treat():
  global final_html
  global df,df_train,df_test,test_train_created,origin_df
  firstkey = False
  secondkey = False
  if request.method == 'POST':
		try:
			Listkey1 = list(MultiDict(request.form).values())
			Listkey2 = MultiDict(request.form)
			for key1 in Listkey1:
				if(key1 == "Replace nulls,NAs with zeros"): 
					firstkey = True
					secondkey = False
				elif(key1 == "Custom: Enter values to replace"):
					secondkey = True
					firstkey = False
			if(secondkey):
				replace_str = str(Listkey2.get('changeval'))
				for key1 in Listkey1:
					if(key1 <> "Replace nulls,NAs with zeros" and key1 <> replace_str and key1 <> "Custom: Enter values to replace"):
						df[key1].fillna(replace_str)
			elif(firstkey):	
				replace_str = str(Listkey2.get('changeval'))
				for key1 in Listkey1:
					if(key1 <> "Replace nulls,NAs with zeros" and key1 <> replace_str and key1 <> "Custom: Enter values to replace"):
						df[key1].fillna(0)
			temp_df = df[1:15]		
			final_html = template.s1 + "<br>Null values were replaced!!<br><br></div>" + temp_df.to_html()
			return final_html
		except:
			final_html = template.s1 + """<br><font color="lightcoral"> Something went wrong. Please try again !! <font><br><br></div>""" + df[1:15].to_html()
			return final_html
  return 'helloo'  

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import get [as 别名]
def treat():
  global final_html
  global df,origin_df
  chi_key = list()
  firstkey = False
  secondkey = False
  if request.method == 'POST':
		Listkey1 = list(MultiDict(request.form).values())
		Listkey2 = MultiDict(request.form)
		df1 = df
		for key1 in Listkey1:
			if(key1 == "Replace nulls,NAs with zeros"): 
				firstkey = True
				secondkey = False
			elif(key1 == "Custom: Enter values to replace"):
				secondkey = True
				firstkey = False
		if(secondkey):
			replace_str = str(Listkey2.get('changeval'))
			for key1 in Listkey1:
				if(key1 <> "Replace nulls,NAs with zeros" and key1 <> replace_str and key1 <> "Custom: Enter values to replace"):
					df[key1].fillna(replace_str)
		elif(firstkey):	
			replace_str = str(Listkey2.get('changeval'))
			for key1 in Listkey1:
				if(key1 <> "Replace nulls,NAs with zeros" and key1 <> replace_str and key1 <> "Custom: Enter values to replace"):
					df[key1].fillna(0)
		temp_df = df[1:15]		
		final_html = template.s1 + "</div><br>Null values were removed<br><br>" + temp_df.to_html()
		return final_html
  return 'helloo'  

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import get [as 别名]
def register():
	data = MultiDict(mapping=request.json)	
	inputs = RegistrationForm(data, csrf_enabled=False)
	
	if not inputs.validate():
		return transform(300, message="Invalid inputs")
	else:
		firstName = data.get('first_name')
		lastName = data.get('last_name')
		email = data.get('email')
		password = data.get('password')

		user = User(email, password, firstName, lastName)
		auth = AuthToken()

		user.tokens.append(auth)

		try:
			db.session.add(user)
			# db.session.add(auth)

			db.session.commit()
		except IntegrityError as e:
			return jsonify({"error": "email already taken"})

		response = auth.__repr__()
		response.update({
			'user_id': user.id,
			'first_name': user.first_name,
			'last_name': user.last_name
		})

		return jsonify(response)

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import get [as 别名]
def cond1():
  global final_html
  global df,df_train,df_test,test_train_created,origin_df
  between_key = False
  great_key = False
  less_key = False
  column_key = ""
  new_column_key = ""
  df['decision'] = False
  if request.method == 'POST':
		try:
			Listkey1 = list(MultiDict(request.form).values())
			Listkey2 = MultiDict(request.form)
			Listkey3 = MultiDict(request.form).keys()
			for key1 in Listkey3:
				if(key1 <> "upper_val" and key1 <> "lower_val" and key1 <> "Submit" and key1 <> "func"):
					column_key = str(key1)
					print "Column key",column_key
			for key1 in Listkey1:
				if(key1 == "between"): 
					between_key = True
					great_key = False
					less_key = False
				elif(key1 == "greater than"):
					between_key = False
					great_key = True
					less_key = False
				elif(key1 == "less than"):
					between_key = False
					great_key = False
					less_key = True
			if(between_key):
				upper_val = float(Listkey2.get('upper_val'))
				lower_val = float(Listkey2.get('lower_val'))
				new_column_key = "Dummy_"+ column_key + "_between_" + str(lower_val) + "_and_" + str(upper_val)
				df['decision'] = Series((df[column_key] > lower_val) & (df[column_key] <	 upper_val))
			elif(great_key):
				upper_val = float(Listkey2.get('upper_val'))		
				new_column_key = "Dummy_"+ column_key + "_great_than_" + str(upper_val)
				df['decision'] = Series(df[column_key] > upper_val)
			elif(less_key):	
				upper_val = float(Listkey2.get('upper_val'))		
				new_column_key = "Dummy_"+ column_key + "_less_than_" + str(upper_val)
				df['decision'] = Series(df[column_key] < upper_val)
			df[new_column_key] = 0
			df[new_column_key][df['decision']] = 1
			df = df.drop('decision',1)
			#print 'COL names',df.columns.values
			temp_df = df[1:15]		
			final_html = template.s1 + "<br>New Dummy variables created based on condition <br><br></div>" + temp_df.to_html()
			return final_html
		except ValueError:
			final_html = template.s1 + """<br><font color="lightcoral"> Please enter valid value </font><br><br></div>""" + df[1:15].to_html()
			return final_html
		except KeyError:
			final_html = template.s1 + """<br><font color="lightcoral"> Please enter valid value </font><br><br></div>""" + df[1:15].to_html()
			return final_html
  return 'helloo'  

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import get [as 别名]
def documents_query(args, fields=None, facets=True, newer_than=None):
    """Parse a user query string, compose and execute a query."""
    if not isinstance(args, MultiDict):
        args = MultiDict(args)
    text = args.get('q', '').strip()
    q = text_query(text)
    q = authz_filter(q)

    if newer_than is not None:
        q = add_filter(q, {
            "range": {
                "created_at": {
                    "gt": newer_than
                }
            }
        })

    # Sorting -- should this be passed into search directly, instead of
    # these aliases?
    sort_mode = args.get('sort', '').strip().lower()
    if text or sort_mode == 'score':
        sort = ['_score']
    elif sort_mode == 'newest':
        sort = [{'dates': 'desc'}, {'created_at': 'desc'}, '_score']
    elif sort_mode == 'oldest':
        sort = [{'dates': 'asc'}, {'created_at': 'asc'}, '_score']
    else:
        sort = [{'updated_at': 'desc'}, {'created_at': 'desc'}, '_score']

    # Extract filters, given in the form: &filter:foo_field=bla_value
    filters = []
    for key in args.keys():
        for value in args.getlist(key):
            if not key.startswith('filter:'):
                continue
            _, field = key.split(':', 1)
            filters.append((field, value))

    for entity in args.getlist('entity'):
        filters.append(('entities.uuid', entity))

    aggs = {}
    if facets:
        aggs = aggregate(q, args, filters)
        aggs = facet_source(q, aggs, filters)
        q = entity_collections(q, aggs, args, filters)

    return {
        'sort': sort,
        'query': filter_query(q, filters),
        'aggregations': aggs,
        '_source': fields or DEFAULT_FIELDS
    }

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import get [as 别名]
def bin2():
  global final_html
  global df,origin_df
  unique_count = 0
  chi_key = list()
  firstkey = ""
  bin_val_fail = False
  if request.method == 'POST':
		Listkey1 = list(MultiDict(request.form).values())
		Listkey2 = MultiDict(request.form)
		bin_val = int(Listkey2.get('changeval'))
		for key1 in Listkey1:
			if(key1 <> "Bin the Columns" and key1 <> str(bin_val)):
				k3 = set(df[key1])
				unique_count = sum(1 for num in k3)
				if(unique_count <= bin_val):
					bin_val_fail = True
					break
				temp_bin_col = pd.qcut(df[key1],bin_val)
				temp_col_name = key1 + "_bin"
				df[temp_col_name] = Series(temp_bin_col.labels)
		temp_df = df[1:15]		
		if(bin_val_fail):
			final_html = template.s1 + "</div><br><br> Bin count is more than the number of categories in columns <br> " + temp_df.to_html()
		else:
			final_html = template.s1 + "</div><br>" + temp_df.to_html()
		return final_html
  return 'helloo'

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import get [as 别名]
def peek_query(args):
    if not isinstance(args, MultiDict):
        args = MultiDict(args)
    text = args.get('q', '').strip()
    q = text_query(text)

    filters = parse_filters(args)
    for entity in args.getlist('entity'):
        filters.append(('entities.id', entity))

    q = filter_query(q, filters, [])
    q = add_filter(q, {
        'not': {
            'terms': {
                'collection_id': authz.collections(authz.READ)
            }
        }
    })
    q = {
        'query': q,
        'size': 0,
        'aggregations': {
            'collections': {
                'terms': {'field': 'collection_id', 'size': 30}
            }
        },
        '_source': False
    }
    # import json
    # print json.dumps(q, indent=2)
    result = get_es().search(index=get_es_index(), body=q,
                             doc_type=TYPE_DOCUMENT)

    aggs = result.get('aggregations', {}).get('collections', {})
    buckets = aggs.get('buckets', [])
    q = Collection.all_by_ids([b['key'] for b in buckets])
    q = q.filter(Collection.creator_id != None)  # noqa
    objs = {o.id: o for o in q.all()}
    roles = {}
    for bucket in buckets:
        collection = objs.get(bucket.get('key'))
        if collection is None or collection.private:
            continue
        if collection.creator_id in roles:
            roles[collection.creator_id]['total'] += bucket.get('doc_count')
        else:
            roles[collection.creator_id] = {
                'name': collection.creator.name,
                'email': collection.creator.email,
                'total': bucket.get('doc_count')
            }

    roles = sorted(roles.values(), key=lambda r: r['total'], reverse=True)
    roles = [format_total(r) for r in roles]
    total = result.get('hits', {}).get('total')
    return format_total({
        'roles': roles,
        'active': total > 0,
        'total': total
    })

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import get [as 别名]
def tree2():
  global final_html
  global df,origin_df
  chi_key = list()
  firstkey = ""
  init_style_string = """<p style="position: absolute; font-size: 12px; top: <top>px; width: <width>px;  height: <height>px; left:<left>px; text-align: center;">tree_text_here</p>"""
  if request.method == 'POST':
		Listkey1 = list(MultiDict(request.form).values())
		Listkey2 = MultiDict(request.form)
		DV_tree = Listkey2.get('DV')
		df1 = df
		for key1 in Listkey1:
			if(key1 <> "Build Tree" and key1 <> DV_tree):
				chi_key.append(key1)
		df1 = df.loc[:,chi_key]
		df2 = df1.values
		temp_count = 0
		Y = df[DV_tree]
		clf = tree.DecisionTreeClassifier()
		clf = clf.fit(df2,Y.values)
		dot_data = StringIO()
		tree.export_graphviz(clf, out_file=dot_data)
		k = dot_data.getvalue()
		k1 = k.split(";")
		left_px = 600
		width_px = 150
		top_px = 50
		height_px = 309
		s = build_tree_html(k,init_style_string,left_px,width_px,top_px,height_px)
		temp_df = df[0:15]	
		t = """</div><div style="float:right;"><br> Decision Tree result <br>"""
		final_html = template.s1 + t + k + "</div><br><br><br>" + temp_df.to_html()
		return final_html
  return 'helloo'  

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import get [as 别名]
def linreg2():
  global final_html
  global df,origin_df
  lin_reg_key = list()
  firstkey = ""
  
  if request.method == 'POST':
		Listkey1 = list(MultiDict(request.form).values())
		Listkey2 = MultiDict(request.form)
		DV_lin_reg = Listkey2.get('DV')
		df1 = df
		for key1 in Listkey1:
			if(key1 <> "Build Linear Regression Model" and key1 <> DV_lin_reg):
				lin_reg_key.append(key1)
		df1 = df.loc[:,lin_reg_key]
		df2 = df1.values
		temp_count = 0
		Y = df[DV_lin_reg]
		linreg = linear_model.LinearRegression()
		fit1 = linreg.fit(df2,Y.values)
		s = fit1.coef_
		temp_df = df[0:15]	
		t = """</div><div style="float:right;"><br> Linear Regression Result <br>"""
		final_html = template.s1 + t + s + "</div><br><br><br>" + temp_df.to_html()
		return final_html
  return 'helloo'  

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import get [as 别名]
def test1():
  global final_html
  global df,df_train,df_test,test_train_created,origin_df
  unique_count = 0
  err_key=0
  if request.method == 'POST':
		try:
			Listkey1 = list(MultiDict(request.form).values())
			Listkey2 = MultiDict(request.form)
			test_per = int(Listkey2.get('test_percent'))
			temp_df = df[1:15]	
			if(float(test_per) < 0 or float(test_per) > 100):
				err_key = 1
			if(err_key==0):
				prop_test = float(test_per)/float(100)
				msk = np.random.rand(len(df)) < prop_test
				df_train = df[~msk]
				df_test = df[msk]
				print "Length of Train",len(df_train)
				print "Length of Test",len(df_test)
				test_train_created = True
				final_html = template.s1 + "</div><br><br> Test and Train datasets created <br> " + temp_df.to_html()
			elif(err_key==1):
				final_html = template.s1 + """<br><br> <font color="red"> Please enter a valid percentage value </font> <br></div> """ + temp_df.to_html()
			return final_html
		except ValueError:
			final_html = template.s1 + """<br><br><font color="lightcoral"> Error. Please enter proper value to create Test and Train dataset. </font><br> </div>""" + df[1:15].to_html()
  return 'helloo'

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import get [as 别名]
def tree3():
  global final_html
  global df,df_train,df_test,test_train_created,origin_df
  chi_key = list()
  init_style_string = template.style_string
  if request.method == 'POST':
		Listkey1 = list(MultiDict(request.form).values())
		Listkey2 = MultiDict(request.form)
		DV_tree = Listkey2.get('DV')
		df1 = df
		for key1 in Listkey1:
			if(key1 <> "Build Tree" and key1 <> DV_tree):
				chi_key.append(key1)
		df1 = df.loc[:,chi_key]
		df2 = df1.values
		Y = df[DV_tree]
		clf = tree.DecisionTreeClassifier()
		clf = clf.fit(df2,Y.values)
		dot_data = StringIO()
		tree.export_graphviz(clf, out_file=dot_data)
		k = dot_data.getvalue()
		left_px = 600
		width_px = 150
		top_px = 50
		height_px = 309
		s = build_tree_html(k,init_style_string,left_px,width_px,top_px,height_px)
		temp_df = df[0:15]	
		t = """</div><div style="width:600px; height:700px; position: absolute; top: 20px; left:500px;"><br> Decision Tree result <br>"""
		final_html = template.s1 + t + k + "<br><br></div>" + temp_df.to_html()
		return final_html
  return 'helloo'  

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import get [as 别名]
def entities_query(args, fields=None, facets=True):
    """Parse a user query string, compose and execute a query."""
    if not isinstance(args, MultiDict):
        args = MultiDict(args)
    text = args.get('q', '').strip()
    if text is None or not len(text):
        q = match_all()
    else:
        q = {
            "query_string": {
                "query": text,
                "fields": ['name^15', 'name_latin^5',
                           'terms^12', 'terms_latin^3',
                           'summary^10', 'summary_latin^7',
                           'description^5', 'description_latin^3'],
                "default_operator": "AND",
                "use_dis_max": True
            }
        }

    q = authz_filter(q)
    filters = parse_filters(args)
    aggs = {'scoped': {'global': {}, 'aggs': {}}}
    if facets:
        facets = args.getlist('facet')
        if 'collections' in facets:
            aggs = facet_collections(q, aggs, filters)
            facets.remove('collections')
        aggs = aggregate(q, aggs, facets)

    sort_mode = args.get('sort', '').strip().lower()
    default_sort = 'score' if len(text) else 'doc_count'
    sort_mode = sort_mode or default_sort
    if sort_mode == 'doc_count':
        sort = [{'doc_count': 'desc'}, '_score']
    elif sort_mode == 'alphabet':
        sort = [{'name': 'asc'}, '_score']
    elif sort_mode == 'score':
        sort = ['_score']

    return {
        'sort': sort,
        'query': filter_query(q, filters, OR_FIELDS),
        'aggregations': aggs,
        '_source': fields or DEFAULT_FIELDS
    }

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import get [as 别名]
def documents_query(args, fields=None, facets=True):
    """Parse a user query string, compose and execute a query."""
    if not isinstance(args, MultiDict):
        args = MultiDict(args)
    text = args.get('q', '').strip()
    q = text_query(text)
    q = authz_filter(q)

    # Sorting -- should this be passed into search directly, instead of
    # these aliases?
    sort_mode = args.get('sort', '').strip().lower()
    if text or sort_mode == 'score':
        sort = ['_score']
    elif sort_mode == 'newest':
        sort = [{'dates': 'desc'}, {'created_at': 'desc'}, '_score']
    elif sort_mode == 'oldest':
        sort = [{'dates': 'asc'}, {'created_at': 'asc'}, '_score']
    else:
        sort = [{'updated_at': 'desc'}, {'created_at': 'desc'}, '_score']

    filters = parse_filters(args)
    for entity in args.getlist('entity'):
        filters.append(('entities.id', entity))

    aggs = {'scoped': {'global': {}, 'aggs': {}}}
    if facets:
        facets = args.getlist('facet')
        if 'collections' in facets:
            aggs = facet_collections(q, aggs, filters)
            facets.remove('collections')
        if 'entities' in facets:
            aggs = facet_entities(aggs, args)
            facets.remove('entities')
        aggs = aggregate(q, aggs, facets)

    signals.document_query_process.send(q=q, args=args)
    return {
        'sort': sort,
        'query': filter_query(q, filters, OR_FIELDS),
        'aggregations': aggs,
        '_source': fields or DEFAULT_FIELDS
    }

# 需要导入模块: from werkzeug.datastructures import MultiDict [as 别名]
# 或者: from werkzeug.datastructures.MultiDict import get [as 别名]
def query(args):
    """ Parse a user query string, compose and execute a query. """
    if not isinstance(args, MultiDict):
        args = MultiDict(args)
    q = text_query(args.get('q', ''))
    q = authz_filter(q)

    # Extract filters, given in the form: &filter:foo_field=bla_value
    filters = []
    for key in args.keys():
        for value in args.getlist(key):
            if not key.startswith('filter:'):
                continue
            _, field = key.split(':', 1)
            filters.append((field, value))

    facets = args.getlist('facet')
    aggs = aggregate(q, facets, filters)

    sort = ['_score']
    if args.get('sort') == 'linkcount':
        sort.insert(0, {'$linkcount': 'desc'})

    q = {
        'sort': sort,
        'query': filter_query(q, filters),
        'aggregations': aggs,
        '_source': DEFAULT_FIELDS
    }

    if args.get('hl'):
        q["highlight"] = {
            "pre_tags": ["<em>"],
            "post_tags": ["</em>"],
            "fields": {
                "$text": {}
            }
        }

    q = paginate(q, args.get('limit'), args.get('offset'))
    return execute_query(args, q, facets)