def ranks(self, **kwargs):
ranks = int(kwargs.get("limit", 1))
col = kwargs.get("col")
attr_type = kwargs.get("attr_type", self.attr_type)
params = {}
params[attr_type] = self.attr["id"]
params["required"] = col
params["show"] = kwargs.get("show", self.attr_type)
params["sumlevel"] = kwargs.get("sumlevel", self.sumlevel(**kwargs))
query = RequestEncodingMixin._encode_params(params)
url = "{}/api?{}".format(API, query)
try:
rank = int(datafold(requests.get(url).json())[0][col])
except ValueError:
app.logger.info("STAT ERROR: {}".format(url))
return ""
del params[attr_type]
params["limit"] = 1
params["order"] = col
params["sort"] = "desc"
if rank <= (ranks / 2 + 1):
results = range(1, ranks + 1)
else:
query = RequestEncodingMixin._encode_params(params)
url = "{}/api?{}".format(API, query)
try:
max_rank = int(datafold(requests.get(url).json())[0][col])
except ValueError:
app.logger.info("STAT ERROR: {}".format(url))
return ""
if rank > (max_rank - ranks / 2 - 1):
results = range(max_rank - ranks + 1, max_rank + 1)
else:
results = range(int(math.ceil(rank - ranks / 2)), int(math.ceil(rank + ranks / 2) + 1))
if kwargs.get("key", False) == "id":
del params["limit"]
params[col] = ",".join([str(r) for r in results])
query = RequestEncodingMixin._encode_params(params)
url = "{}/api?{}".format(API, query)
try:
results = [d[params["show"]] for d in datafold(requests.get(url).json())]
except ValueError:
app.logger.info("STAT ERROR: {}".format(url))
return ""
return ",".join([str(r) for r in results])
def ranks(self, **kwargs):
ranks = int(kwargs.get("limit", 1))
col = kwargs.get("col")
attr_type = kwargs.get("attr_type", self.attr_type)
params = {}
params[attr_type] = self.attr["id"]
params["required"] = col
params["show"] = kwargs.get("show", self.attr_type)
params["sumlevel"] = kwargs.get("sumlevel", self.sumlevel(**kwargs))
query = RequestEncodingMixin._encode_params(params)
url = "{}/api?{}".format(API, query)
try:
rank = int(datafold(requests.get(url).json())[0][col])
except ValueError:
app.logger.info("STAT ERROR: {}".format(url))
return ""
del params[attr_type]
params["limit"] = 1
params["order"] = col
params["sort"] = "desc"
if rank <= (ranks/2 + 1):
results = range(1, ranks + 1)
else:
query = RequestEncodingMixin._encode_params(params)
url = "{}/api?{}".format(API, query)
try:
max_rank = int(datafold(requests.get(url).json())[0][col])
except ValueError:
app.logger.info("STAT ERROR: {}".format(url))
return ""
if rank > (max_rank - ranks/2 - 1):
results = range(max_rank - ranks + 1, max_rank + 1)
else:
results = range(int(math.ceil(rank - ranks/2)), int(math.ceil(rank + ranks/2) + 1))
if kwargs.get("key", False) == "id":
del params["limit"]
params[col] = ",".join([str(r) for r in results])
query = RequestEncodingMixin._encode_params(params)
url = "{}/api?{}".format(API, query)
try:
results = [d[params["show"]] for d in datafold(requests.get(url).json())]
except ValueError:
app.logger.info("STAT ERROR: {}".format(url))
return ""
return ",".join([str(r) for r in results])
def _get_params_with_signature(self, **kwargs):
t = self._to_epoch_miliseconds(datetime.now())
kwargs['timestamp'] = t
body = RequestEncodingMixin._encode_params(kwargs)
sign = hmac.new(self.api_secret, bytes(body, 'utf-8'),
hashlib.sha256).hexdigest()
return {'signature': sign, **kwargs}
def build_signature(request, consumer_secret):
"""Uses the request object and consumer secret to build a signature
This is an internal function and it's highly unlikely than an end
user would ever need to call this
:param request : a twolegged.Request subclass
:param consumer_secret : string
:rtype : string
"""
headers = request.headers()
auth_headers = {k: v for k, v in headers.iteritems() if k == 'Authorization'}
# we are only interested in the POST data if it's passed as form
# parameters while raw POST body is ignored
body = request.form_data()
params = [(k, v) for k, v in request.params() if k != 'oauth_signature']
qs = RequestEncodingMixin._encode_params(params)
collected_params = collect_parameters(qs, body, auth_headers)
normalized_params = normalize_parameters(collected_params)
host = headers.get('Host', None)
normalized_uri = normalize_base_string_uri(request.base_url(), host)
base_string = construct_base_string(unicode(request.method()),
normalized_uri,
normalized_params)
return sign_hmac_sha1(base_string, consumer_secret, None)
def get_authorisation_url(self, scopes):
params = {
'client_id': self.client_id,
'response_type': 'code',
'redirect_uri': self.get_redirect_uri(),
'scope': ' '.join(scopes),
}
return requote_uri(AUTHORISATION_URL.format(params=RequestEncodingMixin._encode_params(params)))
def _pack_file_segment(self, variables, filedata):
# Use the requests module to prepare the file data for us.
files = [('file.data', filedata)]
body, mimetype = RequestEncodingMixin._encode_files(files, variables)
return {
'body': body,
'mimetype': mimetype
}
def call_http_request(url, method, req_headers=None, req_data=None, req_query_string=None, **kwargs):
if config.DEBUG:
from requests.models import RequestEncodingMixin
import os
from publish import ClientService
print 'calling http %s%s pid:%s now_client_count:%s' % (
url, '?' + RequestEncodingMixin._encode_params(req_query_string) if req_query_string else '',
os.getpid(), len(ClientService.clients))
return getattr(requests, method.lower())('%s' % url, params=req_query_string, data=req_data, headers=req_headers,
**kwargs)
def call_http_request(url, method, req_headers=None, req_data=None, req_query_string=None, **kwargs):
d1 = datetime.datetime.now()
result = getattr(requests, method.lower())('%s' % url, params=req_query_string, data=req_data, headers=req_headers,
**kwargs)
d2 = datetime.datetime.now()
from requests.models import RequestEncodingMixin
print 'call http %s%s time:%s' % (url,
'?' + RequestEncodingMixin._encode_params(req_query_string) if req_query_string else '',(d2-d1).total_seconds())
return result
def _request(self, method, url_or_endpoint, **kwargs):
http_client = AsyncHTTPClient()
if not url_or_endpoint.startswith(('http://', 'https://')):
api_base_url = kwargs.pop('api_base_url', self.API_BASE_URL)
url = '{base}{endpoint}'.format(base=api_base_url,
endpoint=url_or_endpoint)
else:
url = url_or_endpoint
headers = {}
params = kwargs.pop('params', {})
if 'access_token' not in params:
params['access_token'] = self.access_token
params = urlencode(dict((k, to_binary(v)) for k, v in params.items()))
url = '{0}?{1}'.format(url, params)
data = kwargs.get('data')
files = kwargs.get('files')
if files:
from requests.models import RequestEncodingMixin
from requests.utils import super_len
body, content_type = RequestEncodingMixin._encode_files(
files, data)
headers['Content-Type'] = content_type
headers['Content-Length'] = super_len(body)
else:
if isinstance(data, dict):
body = json.dumps(data, ensure_ascii=False)
body = body.encode('utf-8')
else:
body = data
result_processor = kwargs.pop('result_processor', None)
timeout = kwargs.get('timeout', self.timeout)
req = HTTPRequest(url=url,
method=method.upper(),
headers=headers,
body=body,
request_timeout=timeout)
res = yield http_client.fetch(req)
if res.error is not None:
raise WeChatClientException(errcode=None,
errmsg=None,
client=self,
request=req,
response=res)
result = self._handle_result(res, method, url, result_processor,
**kwargs)
raise Return(result)
def build_url(url, params):
"""
only for display purpose, parse the params and url to build the final api
:param str url: the url path to use
:param dict params: the dict with the GET parameters, as accepted by requests
:return: the url with the get part
:rtype: str
"""
if params is None:
result = url
else:
result = "%s?%s" % (url, RequestEncodingMixin._encode_params(params))
return result
def call_http_request(url,
method,
req_headers=None,
req_data=None,
req_query_string=None,
**kwargs):
d1 = datetime.datetime.now()
result = getattr(requests, method.lower())('%s' % url,
params=req_query_string,
data=req_data,
headers=req_headers,
**kwargs)
d2 = datetime.datetime.now()
from requests.models import RequestEncodingMixin
print 'call http %s%s time:%s' % (
url, '?' + RequestEncodingMixin._encode_params(req_query_string)
if req_query_string else '', (d2 - d1).total_seconds())
return result
def post(self):
_url = self.get_argument('url', default=None)
data = self.get_argument('data', default=None)
self.client.is_params = False if self.get_argument('is_params', default=False) == '0' else True
if not _url:
raise UnexpectedReuqestDataException
if not _url.startswith('ws://') and not _url.startswith('wss://'):
raise InvalidWebSocketURLException
url = urlparse.urlparse(_url)
# `query_str` is the query string of websocket
query_str = url.query
url = '%s://%s%s' % (url.scheme, url.netloc, url.path)
if self.request.body:
query_str = query_str + '&' + self.request.body
query_str = encoder._encode_params(parse_qs_bytes(query_str))
if not data and not query_str:
logging.warning('No query strings in url, is it HTTP headers injection?')
# raise UnexpectedReuqestDataException
if query_str:
logging.info('Request query string: %s' % query_str)
if data:
logging.info('Request message: %s' % data)
if not self.client.ws:
self.run_websocket('%s?%s' % (url, query_str))
else:
self.client.has_send = False
try:
self.client.ws.send(data if data else '')
except WebSocketException, e:
self.client.ws.close()
self.client.ws = None
logging.error('Error occur: %s' % str(e))
self.finish()
def multi_col_top(profile, params):
namespace = params.pop("namespace")
after = params.pop("after", None)
attr_type = params.get("attr_type", profile.attr_type)
rows = params.pop("rows", False)
cols = params.pop("required", [])
children = params.pop("children", False)
params["show"] = params.get("show", attr_type)
params["limit"] = params.get("limit", 1)
params["sumlevel"] = params.get("sumlevel", "all")
params["sort"] = params.get("sort", "desc")
if children:
params["prefix"] = True
params["where"] = "{}:{}".format(attr_type, profile.children(**params))
prefix_pop = params.pop("prefix")
elif attr_type not in params:
params[attr_type] = profile.id(**params)
dataset = params.pop("dataset", False)
params["required"] = ",".join(cols)
pivot = params.pop("pivot", False)
query = RequestEncodingMixin._encode_params(params)
url = u"{}/api?{}".format(API, query)
try:
r = requests.get(url).json()
except ValueError:
app.logger.info("VAR ERROR: {}".format(url))
return {}
return_obj = {namespace: {} if not rows else []}
if "error" in r or len(r["data"]) == 0:
return return_obj
headers = r["headers"]
if pivot:
base_url = u"{}?{}&col={}&dataset={}".format(url_for("profile.statView"), query, "-".join(pivot["keys"]), dataset)
limit = pivot.get("limit", 1)
cols = pivot["cols"]
api_data = datapivot(datafold(r)[0], pivot["keys"])[:limit]
if rows:
myobject = {}
for index, data_row in enumerate(api_data):
myobject = {}
headers = data_row.keys()
values = data_row.values()
for col in cols:
stat_url = u"{}&rank={}".format(base_url, index + 1)
myobject[col] = render_col(values, headers, col, stat_url)
return_obj[namespace].append(myobject)
else:
values = api_data[0].values()
headers = api_data[0].keys()
stat_url = u"{}&rank=1".format(base_url)
for col in cols:
return_obj[namespace][col] = render_col(values, headers, col, stat_url, dataset)
elif not rows:
if not r["data"]:
return {}
api_data = r["data"][0]
for col in cols:
format_col = col
if col == params["show"]:
stat_col = "name"
else:
stat_col = col
stat_url = u"{}?{}&col={}&dataset={}".format(url_for("profile.statView"), query, stat_col, dataset)
return_obj[namespace][col] = render_col(api_data, headers, col, stat_url, dataset)
else:
if after:
new_order = after.get("order", None)
if new_order:
new_sort = after.get("sort", "desc")
reverse = True if new_sort == "desc" else False
r["data"] = sorted(r["data"], key=lambda k: k[headers.index(new_order)], reverse=reverse)
for index, data_row in enumerate(r["data"]):
myobject = {}
for col in cols:
format_col = col
if col == params["show"]:
stat_col = "name"
else:
stat_col = col
stat_url = u"{}?{}&col={}&rank={}&dataset={}".format(url_for("profile.statView"), query, stat_col, index + 1, dataset)
myobject[col] = render_col(data_row, headers, col, stat_url, dataset)
return_obj[namespace].append(myobject)
return return_obj
def percent(self, **kwargs):
"""str: 2 columns divided by one another """
attr_type = kwargs.get("attr_type", self.attr_type)
attr_id = kwargs.get("attr_id", self.attr["id"])
r = {"num": 1, "den": 1}
for t in r.keys():
key = kwargs.get(t)
params = {}
params["limit"] = 1
params["year"] = kwargs.get("year", "latest")
params = param_format(params)
t_type = kwargs.get("{}_type".format(t), attr_type)
params["show"] = kwargs.get("show", t_type)
params[t_type] = kwargs.get("{}_id".format(t), attr_id)
params["exclude"] = kwargs.get("exclude", kwargs.get("{}_exclude".format(t), ""))
if "top:" in key:
params["col"], params["force"] = key.split(":")[1].split(",")
r["{}_key".format(t)] = params["col"]
r[t] = self.top(**params)["data"][0]
elif "var:" in key:
keys = key.split(":")[1].split(",")
if len(keys) == 2:
keys.append(None)
ns, col, row = keys
r["{}_key".format(t)] = col
r[t] = self.var(namespace=ns, key=col, row=row, format="raw")
elif "," in key:
num, den = key.split(",")
subparams = {}
subparams["num"] = num
subparams["den"] = den
subparams["data_only"] = True
subparams["num_id"] = params[t_type]
subparams["den_id"] = params[t_type]
r["{}_key".format(t)] = None
r[t] = self.percent(**subparams)
else:
params["required"] = key
r["{}_key".format(t)] = key
# convert request arguments into a url query string
query = RequestEncodingMixin._encode_params(params)
url = u"{}/api?{}".format(API, query)
try:
r[t] = datafold(requests.get(url).json())
except ValueError:
app.logger.info("STAT ERROR: {}".format(url))
return "N/A"
if len(r[t]) == 0:
return "N/A"
r[t] = r[t][0][key]
if r[t] in [None, "N/A"]:
return "N/A"
diff = kwargs.get("diff", False)
text = kwargs.get("text", False)
if text and text in TEXTCOMPARATORS:
r["num"] = float(num_format(r["num"], r["num_key"], False, suffix=False).replace(",", ""))
r["den"] = float(num_format(r["den"], r["den_key"], False, suffix=False).replace(",", ""))
if r["num"] == 0 or r["den"] == 0:
val = 0
elif diff:
val = r["num"] - r["den"]
else:
val = float(r["num"])/float(r["den"])
if kwargs.get("invert", False):
val = 1 - val
if kwargs.get("data_only", False):
return val
if text and text in TEXTCOMPARATORS:
text = TEXTCOMPARATORS[text]
if diff:
if val > 0:
return text[0]
elif val < 0:
return text[1]
else:
return text[2]
else:
if val > 1:
return text[0]
elif val < 1:
return text[1]
else:
return text[2]
elif diff or kwargs.get("ratio", False):
return num_format(abs(val))
else:
return "{}%".format(num_format(val * 100))
def parents(self, **kwargs):
id_only = kwargs.get("id_only", False)
limit = kwargs.pop("limit", None)
attr_id = self.id(**kwargs)
prefix = kwargs.get("prefix", None)
if (prefix or limit) and id_only == False:
top = get_parents(attr_id, self.attr_type)
if prefix:
top = [p for p in top if p["id"].startswith(prefix)]
if limit:
top = top[-int(limit):]
top = self.make_links(top)
return top
if self.attr["id"] == "01000US":
col = kwargs.get("col", False)
if col:
params = {
"show": "geo",
"required": col,
"sumlevel": "state",
"order": col,
"sort": "desc",
"year": "latest"
}
query = RequestEncodingMixin._encode_params(params)
url = "{}/api?{}".format(API, query)
try:
results = [r for r in datafold(requests.get(url).json()) if r[col]]
except ValueError:
app.logger.info("STAT ERROR: {}".format(url))
return ""
results = results[:2] + results[-2:]
if id_only:
return ",".join([r["geo"] for r in results])
else:
return [fetch(r["geo"], "geo") for r in results]
else:
results = [
{"id": "04000US06", "name": "California", "url_name": "california"},
{"id": "04000US48", "name": "Texas", "url_name": "texas"},
{"id": "04000US36", "name": "New York", "url_name": "new-york"},
{"id": "16000US1150000", "name":"Washington D.C.", "url_name": "washington-dc"},
{"id": "16000US3651000", "name":"New York, NY", "url_name": "new-york-ny"},
{"id": "16000US0644000", "name":"Los Angeles, CA", "url_name": "los-angeles-ca"},
{"id": "16000US1714000", "name":"Chicago, IL", "url_name": "chicago-il"}
]
if id_only:
return ",".join([r["id"] for r in results])
else:
return results
results = [p for p in get_parents(attr_id, self.attr_type) if p["id"] != attr_id]
results = self.get_uniques(results)
for p in results:
if self.attr_type == "geo":
level = p["id"][:3]
elif self.attr_type == "cip":
level = str(len(p["id"]))
else:
level = str(fetch(p["id"], self.attr_type)["level"])
p["sumlevel"] = SUMLEVELS[self.attr_type][level]["label"]
if prefix:
results = [r for r in results if r["id"].startswith(prefix)]
if limit:
results = results[-int(limit):]
if id_only:
return ",".join([r["id"] for r in results])
else:
return results
def __init__(self, params, highlight=False, profile=False, select=False, slug=False):
"""Initializes a new Viz class.
Args:
config (str): The YAML configuration file as one long string.
profile (Profile): The Profile class instance this Section will be a part of.
"""
self.highlight = params.pop("highlight", highlight)
self.profile = profile.attr
self.select = select
self.profile_type = profile.attr_type
self.className = params.pop("class", False)
self.slug = slug
# force the data of params into a list
data = params.pop("data") if isinstance(params["data"], list) else [params.pop("data")]
# remove sumlevel if it exists
sumlevel = params.pop("sumlevel", None)
# loop through each data and append to self.data
self.data = []
for d in data:
# create a new dict containing the 'split' and 'static' params
data_obj = {
"map": d.pop("map", None),
"split": d.pop("split", None),
"static": d.pop("static", None),
"share": d.pop("share", None)
}
# Set fallback API params
d = param_format(d)
# create the data URL
p = RequestEncodingMixin._encode_params(d)
data_obj["url"] = "{}/api/?{}".format(API, p)
# store the params in the return dict
data_obj["params"] = d
# self.data.append(data_obj)
if "limit" in d and "year" in d and d["year"] == "all":
for year in year_cache[requests.get(data_obj["url"].replace("/api/", "/api/logic/")).json()["tables"][0]["table"]]:
new_obj = copy.deepcopy(data_obj)
year = str(int(year))
new_obj["url"] = new_obj["url"].replace("year=all", "year={}".format(year))
new_obj["params"]["year"] = year
self.data.append(new_obj)
else:
# append the data dict to self.data
self.data.append(data_obj)
self.attrs = []
if "attrs" in params:
# force the attrs of params into a list
attrs = params.pop("attrs") if isinstance(params["attrs"], list) else [params.pop("attrs")]
# loop through each data and append to self.data
self.attrs = [{"type": a, "url": "{}/attrs/{}/".format(API, a)} for a in attrs]
# set self.config to the params
self.config = params
if "mouse" in params:
if params["mouse"] == "NO":
self.config["mouse"] = False
else:
self.config["mouse"] = True
# set the tooltip config using the function
self.config["tooltip"] = params.pop("tooltip", {})
self.config["tooltip"]["value"] = self.tooltip()
# set default depth to zero
self.config["depth"] = int(params["depth"]) if "depth" in params else 0
# set default text to "name"
self.config["text"] = params["text"] if "text" in params else "name"
def percent(self, **kwargs):
"""str: 2 columns divided by one another """
attr_type = kwargs.get("attr_type", self.attr_type)
attr_id = kwargs.get("attr_id", self.attr["id"])
r = {"num": 1, "den": 1}
for t in r.keys():
key = kwargs.get(t)
params = {}
params["limit"] = 1
params["year"] = kwargs.get("year", "latest")
params = param_format(params)
t_type = kwargs.get("{}_type".format(t), attr_type)
params["show"] = kwargs.get("show", t_type)
params[t_type] = kwargs.get("{}_id".format(t), attr_id)
params["exclude"] = kwargs.get("exclude", kwargs.get("{}_exclude".format(t), ""))
if "top:" in key:
params["col"], params["force"] = key.split(":")[1].split(",")
r["{}_key".format(t)] = params["col"]
r[t] = self.top(**params)["data"][0]
elif "var:" in key:
keys = key.split(":")[1].split(",")
if len(keys) == 2:
keys.append(None)
ns, col, row = keys
r["{}_key".format(t)] = col
r[t] = self.var(namespace=ns, key=col, row=row, format="raw")
elif "," in key:
num, den = key.split(",")
subparams = {}
subparams["num"] = num
subparams["den"] = den
subparams["data_only"] = True
subparams["num_id"] = params[t_type]
subparams["den_id"] = params[t_type]
r["{}_key".format(t)] = None
r[t] = self.percent(**subparams)
else:
params["required"] = key
r["{}_key".format(t)] = key
# convert request arguments into a url query string
query = RequestEncodingMixin._encode_params(params)
url = u"{}/api?{}".format(API, query)
try:
r[t] = datafold(requests.get(url).json())
except ValueError:
app.logger.info("STAT ERROR: {}".format(url))
return "N/A"
if len(r[t]) == 0:
return "N/A"
r[t] = r[t][0][key]
if r[t] in [None, "N/A"]:
return "N/A"
diff = kwargs.get("diff", False)
text = kwargs.get("text", False)
if text and text in TEXTCOMPARATORS:
r["num"] = float(num_format(r["num"], r["num_key"], False, suffix=False).replace(",", ""))
r["den"] = float(num_format(r["den"], r["den_key"], False, suffix=False).replace(",", ""))
if r["num"] == 0 or r["den"] == 0:
val = 0
elif diff:
val = r["num"] - r["den"]
else:
val = float(r["num"])/float(r["den"])
if kwargs.get("invert", False):
val = 1 - val
if kwargs.get("data_only", False):
return val
if text and text in TEXTCOMPARATORS:
text = TEXTCOMPARATORS[text]
if diff:
if val > 0:
return text[0]
elif val < 0:
return text[1]
else:
return text[2]
else:
if val > 1:
return text[0]
elif val < 1:
return text[1]
else:
return text[2]
elif diff or kwargs.get("ratio", False):
return num_format(abs(val))
else:
return "{}%".format(num_format(val * 100))
def parents(self, **kwargs):
id_only = kwargs.get("id_only", False)
limit = kwargs.pop("limit", None)
attr_id = self.id(**kwargs)
prefix = kwargs.get("prefix", None)
if (prefix or limit) and id_only == False:
top = get_parents(attr_id, self.attr_type)
if prefix:
top = [p for p in top if p["id"].startswith(prefix)]
if limit:
top = top[-int(limit):]
top = self.make_links(top)
return top
if self.attr["id"] == "01000US":
col = kwargs.get("col", False)
if col:
params = {
"show": "geo",
"required": col,
"sumlevel": "state",
"order": col,
"sort": "desc",
"year": "latest"
}
query = RequestEncodingMixin._encode_params(params)
url = "{}/api?{}".format(API, query)
try:
results = [r for r in datafold(requests.get(url).json()) if r[col]]
except ValueError:
app.logger.info("STAT ERROR: {}".format(url))
return ""
results = results[:2] + results[-2:]
if id_only:
return ",".join([r["geo"] for r in results])
else:
return [fetch(r["geo"], "geo") for r in results]
else:
results = [
{"id": "04000US06", "name": "California", "url_name": "california"},
{"id": "04000US48", "name": "Texas", "url_name": "texas"},
{"id": "04000US36", "name": "New York", "url_name": "new-york"},
{"id": "16000US1150000", "name":"Washington D.C.", "url_name": "washington-dc"},
{"id": "16000US3651000", "name":"New York, NY", "url_name": "new-york-ny"},
{"id": "16000US0644000", "name":"Los Angeles, CA", "url_name": "los-angeles-ca"},
{"id": "16000US1714000", "name":"Chicago, IL", "url_name": "chicago-il"}
]
if id_only:
return ",".join([r["id"] for r in results])
else:
return results
results = [p for p in get_parents(attr_id, self.attr_type) if p["id"] != attr_id]
results = self.get_uniques(results)
if prefix:
results = [r for r in results if r["id"].startswith(prefix)]
if limit:
results = results[-int(limit):]
if id_only:
return ",".join([r["id"] for r in results])
else:
return results
def multi_col_top(profile, params):
namespace = params.pop("namespace")
after = params.pop("after", None)
attr_type = params.get("attr_type", profile.attr_type)
rows = params.pop("rows", False)
cols = params.pop("required", [])
children = params.pop("children", False)
params["show"] = params.get("show", attr_type)
params["limit"] = params.get("limit", 1)
params["sumlevel"] = params.get("sumlevel", "all")
params["sort"] = params.get("sort", "desc")
if children:
params["prefix"] = True
params["where"] = "{}:{}".format(attr_type, profile.children(**params))
prefix_pop = params.pop("prefix")
elif attr_type not in params:
params[attr_type] = profile.id(**params)
dataset = params.pop("dataset", False)
params["required"] = ",".join(cols)
pivot = params.pop("pivot", False)
query = RequestEncodingMixin._encode_params(params)
url = u"{}/api?{}".format(API, query)
try:
r = requests.get(url).json()
except ValueError:
app.logger.info("VAR ERROR: {}".format(url))
return {}
return_obj = {namespace: {} if not rows else []}
if "error" in r or len(r["data"]) == 0:
return return_obj
headers = r["headers"]
if pivot:
base_url = u"{}?{}&col={}&dataset={}".format(
url_for("profile.statView"), query, "-".join(pivot["keys"]),
dataset)
limit = pivot.get("limit", 1)
cols = pivot["cols"]
api_data = datapivot(datafold(r)[0], pivot["keys"])[:limit]
if rows:
myobject = {}
for index, data_row in enumerate(api_data):
myobject = {}
headers = data_row.keys()
values = data_row.values()
for col in cols:
stat_url = u"{}&rank={}".format(base_url, index + 1)
myobject[col] = render_col(values, headers, col, stat_url)
return_obj[namespace].append(myobject)
else:
values = api_data[0].values()
headers = api_data[0].keys()
stat_url = u"{}&rank=1".format(base_url)
for col in cols:
return_obj[namespace][col] = render_col(
values, headers, col, stat_url, dataset)
elif not rows:
if not r["data"]:
return {}
api_data = r["data"][0]
for col in cols:
format_col = col
if col == params["show"]:
stat_col = "name"
else:
stat_col = col
stat_url = u"{}?{}&col={}&dataset={}".format(
url_for("profile.statView"), query, stat_col, dataset)
return_obj[namespace][col] = render_col(api_data, headers, col,
stat_url, dataset)
else:
if after:
new_order = after.get("order", None)
if new_order:
new_sort = after.get("sort", "desc")
mute = after.get("mute", [])
reverse = True if new_sort == "desc" else False
show = params["show"].split(",")[0]
r["data"] = sorted(r["data"],
key=lambda k: 0 if k[headers.index(show)] in
mute else k[headers.index(new_order)],
reverse=reverse)
aggregate = after.get("aggregate", None)
if aggregate:
method = after.get("method", "sum")
myobject = {}
for row in r["data"]:
aggid = row[headers.index(aggregate)]
if aggid in myobject:
prev = myobject[aggid]
else:
prev = [None] * len(headers)
for col in headers:
i = headers.index(col)
if prev[i] == None or isinstance(
row[i], basestring
) or col == aggregate or col == "year":
prev[i] = row[i]
elif col == aggregate or col:
if method == "max":
prev[i] = max([prev[i], row[i]])
else:
prev[i] = prev[i] + row[i]
myobject[aggid] = prev
reverse = False if params["sort"] == "asc" else True
r["data"] = sorted(
[myobject[k] for k in myobject],
key=lambda k: k[headers.index(params["order"])],
reverse=reverse)
for index, data_row in enumerate(r["data"]):
myobject = {}
for col in cols:
format_col = col
if col == params["show"]:
stat_col = "name"
else:
stat_col = col
stat_url = u"{}?{}&col={}&rank={}&dataset={}".format(
url_for("profile.statView"), query, stat_col, index + 1,
dataset)
myobject[col] = render_col(data_row, headers, col, stat_url,
dataset)
return_obj[namespace].append(myobject)
return return_obj
def _request(self, method, url_or_endpoint, **kwargs):
http_client = AsyncHTTPClient()
if not url_or_endpoint.startswith(('http://', 'https://')):
api_base_url = kwargs.pop('api_base_url', self.API_BASE_URL)
url = '{base}{endpoint}'.format(
base=api_base_url,
endpoint=url_or_endpoint
)
else:
url = url_or_endpoint
headers = {}
params = kwargs.pop('params', {})
if 'access_token' not in params:
params['access_token'] = self.access_token
params = urlencode(dict((k, to_binary(v)) for k, v in params.items()))
url = '{0}?{1}'.format(url, params)
data = kwargs.get('data')
files = kwargs.get('files')
if files:
from requests.models import RequestEncodingMixin
from requests.utils import super_len
body, content_type = RequestEncodingMixin._encode_files(
files,
data
)
headers['Content-Type'] = content_type
headers['Content-Length'] = super_len(body)
else:
if isinstance(data, dict):
body = json.dumps(data, ensure_ascii=False)
body = body.encode('utf-8')
else:
body = data
result_processor = kwargs.pop('result_processor', None)
timeout = kwargs.get('timeout', self.timeout)
req = HTTPRequest(
url=url,
method=method.upper(),
headers=headers,
body=body,
request_timeout=timeout
)
res = yield http_client.fetch(req)
if res.error is not None:
raise WeChatClientException(
errcode=None,
errmsg=None,
client=self,
request=req,
response=res
)
result = self._handle_result(
res, method, url, result_processor, **kwargs
)
raise Return(result)
def _pack_file_segment(self, variables, filedata):
# Use the requests module to prepare the file data for us.
files = [('file.data', filedata)]
body, mimetype = RequestEncodingMixin._encode_files(files, variables)
return {'body': body, 'mimetype': mimetype}
def __init__(self,
params,
highlight=False,
profile=False,
select=False,
slug=False,
topic=False):
"""Initializes a new Viz class.
Args:
config (str): The YAML configuration file as one long string.
profile (Profile): The Profile class instance this Section will be a part of.
"""
self.highlight = params.pop("highlight", highlight)
self.profile = profile.attr
self.select = select
self.profile_type = profile.attr_type
self.className = params.pop("class", False)
self.slug = slug
# force the data of params into a list
data = params.pop("data") if isinstance(
params["data"], list) else [params.pop("data")]
data = [d for d in data if self.allowed_levels(d)]
# remove sumlevel if it exists
sumlevel = params.pop("sumlevel", None)
# loop through each data and append to self.data
self.data = []
for d in data:
# create a new dict containing the 'split' and 'static' params
data_obj = {
"join": d.pop("join", None),
"divide": d.pop("divide", None),
"map": d.pop("map", None),
"merge": d.pop("merge", None),
"split": d.pop("split", None),
"static": d.pop("static", None),
"share": d.pop("share", None),
"sum": d.pop("sum", None),
}
# Set fallback API params
d = param_format(d)
# create the data URL
p = RequestEncodingMixin._encode_params(d)
join = "join/" if data_obj["join"] else ""
data_obj["url"] = "{}/api/{}?{}".format(API, join, p)
# store the params in the return dict
data_obj["params"] = d
# self.data.append(data_obj)
if "limit" in d and "year" in d and d["year"] == "all":
for year in year_cache[requests.get(data_obj["url"].replace(
"/api/", "/api/logic/")).json()["tables"][0]["table"]]:
new_obj = copy.deepcopy(data_obj)
year = str(int(year))
new_obj["url"] = new_obj["url"].replace(
"year=all", "year={}".format(year))
new_obj["params"]["year"] = year
self.data.append(new_obj)
else:
# append the data dict to self.data
self.data.append(data_obj)
self.attrs = []
if "attrs" in params:
# force the attrs of params into a list
attrs = params.pop("attrs") if isinstance(
params["attrs"], list) else [params.pop("attrs")]
# loop through each data and append to self.data
self.attrs = [{
"type": a,
"url": "{}/attrs/{}/".format(API, a)
} for a in attrs]
# set self.config to the params
self.config = params
if "mouse" in params:
if params["mouse"] == "NO":
self.config["mouse"] = False
else:
self.config["mouse"] = True
# set the tooltip config using the function
self.config["tooltip"] = params.pop("tooltip", {})
self.config["tooltip"]["value"] = self.tooltip()
tooltipValues = []
if "year" not in tooltipValues:
tooltipValues.append("year")
for value in self.config["tooltip"]["value"]:
tooltipValues.append(value)
if value in COLLECTIONYEARS:
tooltipValues.append("{}_collection".format(value))
self.config["tooltip"]["value"] = tooltipValues
# set default depth to zero
self.config["depth"] = int(params["depth"]) if "depth" in params else 0
# set default text to "name"
self.config["text"] = params["text"] if "text" in params else "name"
if topic and "cart" in topic:
self.cart = topic["cart"]
else:
self.cart = False
def ranks(self, **kwargs):
ranks = int(kwargs.get("limit", 1))
col = kwargs.get("col")
attr_type = kwargs.get("attr_type", self.attr_type)
params = {}
params[attr_type] = self.attr["id"]
params["required"] = col
params["show"] = kwargs.get("show", self.attr_type)
params["year"] = kwargs.get("year", "latest")
params["sumlevel"] = kwargs.get("sumlevel", self.sumlevel(**kwargs))
query = RequestEncodingMixin._encode_params(params)
url = "{}/api?{}".format(API, query)
try:
rank = int(datafold(requests.get(url).json())[0][col])
except ValueError:
app.logger.info("STAT ERROR: {}".format(url))
return ""
del params[attr_type]
params["limit"] = 1
params["order"] = col
params["sort"] = "desc"
if rank <= (ranks / 2 + 1):
results = range(1, ranks + 1)
else:
query = RequestEncodingMixin._encode_params(params)
url = "{}/api?{}".format(API, query)
try:
max_rank = int(datafold(requests.get(url).json())[0][col])
except ValueError:
app.logger.info("STAT ERROR: {}".format(url))
return ""
if rank > (max_rank - ranks / 2 - 1):
results = range(max_rank - ranks + 1, max_rank + 1)
else:
results = range(int(math.ceil(rank - ranks / 2)),
int(math.ceil(rank + ranks / 2) + 1))
prev = kwargs.get("prev", False)
next = kwargs.get("next", False)
if prev:
if rank == results[0]:
return "N/A"
else:
results = [results[results.index(rank) - 1]]
if next:
if rank == results[-1]:
return "N/A"
else:
results = [results[results.index(rank) + 1]]
key = kwargs.get("key", False)
if key == "id" or key == "name":
del params["limit"]
params[col] = ",".join([str(r) for r in results])
query = RequestEncodingMixin._encode_params(params)
url = "{}/api?{}".format(API, query)
try:
results = datafold(requests.get(url).json())
except ValueError:
app.logger.info("STAT ERROR: {}".format(url))
return ""
if key == "id":
results = [d[params["show"]] for d in results]
elif key == "name":
return self.make_links([
fetch(d[params["show"]], params["show"]) for d in results
], params["show"])
return ",".join([str(r) for r in results])
def multi_col_top(profile, params):
namespace = params.pop("namespace")
after = params.pop("after", None)
attr_type = params.get("attr_type", profile.attr_type)
rows = params.pop("rows", False)
cols = params.pop("required", [])
children = params.pop("children", False)
params["show"] = params.get("show", attr_type)
params["limit"] = params.get("limit", 1)
params["sumlevel"] = params.get("sumlevel", "all")
params["sort"] = params.get("sort", "desc")
if children:
params["prefix"] = True
params["where"] = "{}:{}".format(attr_type, profile.children(**params))
prefix_pop = params.pop("prefix")
elif attr_type not in params:
params[attr_type] = profile.id(**params)
dataset = params.pop("dataset", False)
params["required"] = ",".join(cols)
pivot = params.pop("pivot", False)
query = RequestEncodingMixin._encode_params(params)
url = u"{}/api?{}".format(API, query)
try:
r = requests.get(url).json()
except ValueError:
app.logger.info("VAR ERROR: {}".format(url))
return {}
headers = r["headers"]
return_obj = {namespace: {} if not rows else []}
if len(r["data"]) == 0:
return return_obj
if pivot:
base_url = u"{}?{}&col={}&dataset={}".format(url_for("profile.statView"), query, "-".join(pivot["keys"]), dataset)
limit = pivot.get("limit", 1)
cols = pivot["cols"]
api_data = datapivot(datafold(r)[0], pivot["keys"])[:limit]
if rows:
myobject = {}
for index, data_row in enumerate(api_data):
myobject = {}
headers = data_row.keys()
values = data_row.values()
for col in cols:
stat_url = u"{}&rank={}".format(base_url, index + 1)
myobject[col] = render_col(values, headers, col, stat_url)
return_obj[namespace].append(myobject)
else:
values = api_data[0].values()
headers = api_data[0].keys()
stat_url = u"{}&rank=1".format(base_url)
for col in cols:
return_obj[namespace][col] = render_col(values, headers, col, stat_url, dataset)
elif not rows:
if not r["data"]:
return {}
api_data = r["data"][0]
for col in cols:
format_col = col
if col == params["show"]:
stat_col = "name"
else:
stat_col = col
stat_url = u"{}?{}&col={}&dataset={}".format(url_for("profile.statView"), query, stat_col, dataset)
return_obj[namespace][col] = render_col(api_data, headers, col, stat_url, dataset)
else:
if after:
new_order = after.get("order", None)
if new_order:
new_sort = after.get("sort", "desc")
reverse = True if new_sort == "desc" else False
r["data"] = sorted(r["data"], key=lambda k: k[headers.index(new_order)], reverse=reverse)
for index, data_row in enumerate(r["data"]):
myobject = {}
for col in cols:
format_col = col
if col == params["show"]:
stat_col = "name"
else:
stat_col = col
stat_url = u"{}?{}&col={}&rank={}&dataset={}".format(url_for("profile.statView"), query, stat_col, index + 1, dataset)
myobject[col] = render_col(data_row, headers, col, stat_url, dataset)
return_obj[namespace].append(myobject)
return return_obj
def test_content_md5(self):
data = {'signature': "HPMOHRgPSMKdXrU6AqQs/i9S7alOakkHsJiqLGmInt05Cxj6b/WhS7kJxbIQxKmDW08YKzoFnbVZIoTI2qofEzk="}
assert RequestEncodingMixin._encode_params(data) == "signature=HPMOHRgPSMKdXrU6AqQs%2Fi9S7alOakkHsJiqLGmInt05Cxj6b%2FWhS7kJxbIQxKmDW08YKzoFnbVZIoTI2qofEzk%3D"
assert hashlib.md5(RequestEncodingMixin._encode_params(data).encode("utf-8")).hexdigest() == "fdfc1a717d2c97649f3b8b2142507129"
'force_loging': '0',
'device_model': 'Symphony w68',
'device_platform': 'Android',
'device_uuid': 'b86e58c13a7aae35',
'device_imsi': 'b86e58c13a7aae35',
'device_version': '4.2.2',
'operator': '',
'network_type': 'mobile',
'app_version': '4.0.1'
}
num = raw_input('number: ')
_pass = raw_input('password: '******'conn': str(num), 'password': str(_pass)})
resp = session.post(HOST + LOGIN + time_dc(), data=REM._encode_params(data))
del data['password'], data['force_loging']
data.update({
'session_key': resp.json()['sessionKey'],
'conn_type': resp.json()['connections'][0]['conn_type'],
'operator': resp.json()['connections'][0]['operator'],
'conn': resp.json()['connections'][0]['conn'],
'ref_number': resp.json()['user']['mobile'],
'lang': 'en',
'page': '1',
'start': '0',
'limit': '15'
})
resp = session.post(HOST + PACKAGES + time_dc(), data=data)
del data['page'], data['start'], data['limit']
def _encode_multipart_formdata(fields, files):
body, content_type = RequestEncodingMixin._encode_files(files, fields)
return content_type, body
def aiohttp_payload(data, encoding="utf8"):
payload = RequestEncodingMixin._encode_params(data).encode(encoding)
stream = StreamReader()
stream.feed_data(payload)
stream.feed_eof()
return stream
def stat(params, col="name", dataset=False, data_only=False, moe=False, truncate=0):
# convert request arguments into a url query string
rank = int(params.pop("rank", "1"))
if "limit" in params:
limit = int(params["limit"])
else:
limit = 1
if rank > 1 and limit == 1:
params["limit"] = rank
query = RequestEncodingMixin._encode_params(params)
url = "{}/api?{}".format(API, query)
stat_url = "{}?{}&col={}&dataset={}&moe={}&rank={}".format(url_for("profile.statView"), query, col, dataset, moe, str(rank))
try:
r = requests.get(url).json()
except ValueError:
app.logger.info("STAT ERROR: {}".format(url))
return {
"url": stat_url,
"value": "N/A"
}
if data_only:
return r
else:
r = datafold(r)
if dataset == "stat":
if isinstance(r[0][col], list):
r = [{params["show"]:x} for x in r[0][col]]
col = "name"
if len(r) == 0:
return {
"url": stat_url,
"value": "N/A"
}
# if the output key is 'name', fetch attributes for each return and create an array of 'name' values
# else create an array of the output key for each returned datapoint
vals = []
show = params["show"].split(",")[-1]
if col == "ratio":
if limit == 1:
vals = sorted([v for k, v in r[0].iteritems() if k in params["required"].split(",")], reverse=True)
if vals[0] == 0 or vals[1] == 0:
val = 0
else:
val = vals[0]/vals[1]
return num_format(val, key=col)
else:
denom = max([d[params["order"]] for d in r[1:]])
return num_format(r[0][params["order"]]/denom, key=col)
if col == "diff":
return num_format(r[0][params["order"]] - r[1][params["order"]], key=col)
if col in COLMAP or "-" in col:
vals = datapivot(r, col.split("-"), sort="desc")
vals = [v for v in vals[rank - 1:limit]]
if moe:
top = [v["moe"] for v in vals]
else:
top = [v["name"] for v in vals]
vals = [v["value"] for v in vals]
else:
if rank > 1:
r = r[rank-1:]
if moe:
top = [d[moe] for d in r]
elif col == "name":
if dataset in ["acs", "pums"]:
attr = "{}_{}".format(dataset, show)
else:
attr = show
top = [fetch(d[show], attr) for d in r]
if attr in PROFILES or attr in CROSSWALKS:
top = [(t["id"], t["display_name"] if "display_name" in t else t[col], t["url_name"] if "url_name" in t and t["url_name"] else t["id"]) for t in top]
top = [u"<a href='{}'>{}</a>".format(url_for("profile.profile", attr_type=attr, attr_id=t[2]), t[1]) if attr != "geo" or t[0][:3] != "140" else t[1] for t in top]
else:
top = [t["display_name"] if "display_name" in t else t[col] for t in top]
elif col == "id":
top = [d[show] for d in r]
else:
top = [d[col] for d in r]
if col != "id":
if moe:
col = moe
top = [num_format(t, col) if isinstance(t, (int, float)) else t for t in top]
# coerce all values to strings
top = [u"{}".format(t) if t != "" else u"N/A" for t in top]
if col == "id":
top = u",".join(top)
else:
num_items = len(top)
if truncate and num_items > truncate:
top, rest = top[:int(truncate)], top[int(truncate):]
# now stringify
top = u"{}; <a href='#' class='show-more pri-link'>& {} more</a>".format(u"; ".join(top), len(rest))
if len(rest) > 1:
rest = u"; ".join(rest)
else:
rest = u"and {}".join(rest[-1])
top = u"<span>{}</span><span class='the_rest'>{}</span>".format(top, rest)
else:
if num_items > 1:
top[-1] = u"and {}".format(top[-1])
if num_items == 2:
top = u" ".join(top)
else:
top = u"; ".join(top)
# otherwise, return the list joined with commans
return {
"url": stat_url,
"value": top,
"data": vals
}
def __init__(self, params, highlight=False, profile=False):
"""Initializes a new Viz class.
Args:
config (str): The YAML configuration file as one long string.
profile (Profile): The Profile class instance this Section will be a part of.
"""
self.highlight = params.pop("highlight", highlight)
self.profile = profile.attr
self.profile_type = profile.attr_type
# force the data of params into a list
data = params.pop("data") if isinstance(
params["data"], list) else [params.pop("data")]
# remove sumlevel if it exists
sumlevel = params.pop("sumlevel", None)
# loop through each data and append to self.data
self.data = []
for d in data:
# create a new dict containing the 'split' and 'static' params
data_obj = {
"map": d.pop("map", None),
"split": d.pop("split", None),
"static": d.pop("static", None),
"share": d.pop("share", None)
}
# Set fallback API params
d = param_format(d)
# create the data URL
p = RequestEncodingMixin._encode_params(d)
data_obj["url"] = "{}/api/?{}".format(API, p)
# store the params in the return dict
data_obj["params"] = d
# append the data dict to self.data
self.data.append(data_obj)
self.attrs = []
if "attrs" in params:
# force the attrs of params into a list
attrs = params.pop("attrs") if isinstance(
params["attrs"], list) else [params.pop("attrs")]
# loop through each data and append to self.data
self.attrs = [{
"type": a,
"url": "{}/attrs/{}/".format(API, a)
} for a in attrs]
# set self.config to the params
self.config = params
if "mouse" in params:
if params["mouse"] == "NO":
self.config["mouse"] = False
else:
self.config["mouse"] = True
# set the tooltip config using the function
self.config["tooltip"] = params.pop("tooltip", {})
self.config["tooltip"]["value"] = self.tooltip()
# set default depth to zero
self.config["depth"] = int(params["depth"]) if "depth" in params else 0
# set default text to "name"
self.config["text"] = params["text"] if "text" in params else "name"
