def test_01(self):
youtube_id = "4VYAaLh3XZg"
scopes = ["https://www.googleapis.com/auth/youtube.readonly"]
cachefile = os.path.join(FILE_DIR, "token.pickle")
cachefuncs = CredentialCache.filepath2cachefuncs_pickle(cachefile)
flow = InstalledAppFlow.from_client_secrets_file(
FoxylibGoogleapi.Oauth.filepath_credentials(), scopes)
credentials = GoogleAPITool.cache_or_func2cred(
cachefuncs, partial(flow.run_local_server, port=0))
youtube = googleapiclient.discovery.build("youtube",
"v3",
credentials=credentials,
cache_discovery=False)
request = youtube.videos().list(
part="snippet,contentDetails,statistics", id=youtube_id)
response = request.execute()
hyp_01 = JsonTool.down(response, ["kind"])
self.assertEqual(hyp_01, "youtube#videoListResponse")
item = l_singleton2obj(JsonTool.down(response, ["items"]))
hyp_02 = JsonTool.down(item, ["id"])
self.assertEqual(hyp_02, youtube_id)
hyp_03 = JsonTool.down(item, ["kind"])
self.assertEqual(hyp_03, "youtube#video")
def doc2product_list(cls, doc):
tradegoods = doc.get("tradegoods") or []
product_list = [{
Product.Field.TRADEGOOD:
JsonTool.down(tg, ["name", "en"]),
Product.Field.PRICE:
JsonTool.down(tg, ["price"]),
} for tg in tradegoods]
return product_list
def result_item2price(item):
port_id = JsonTool.down(item, ["_id", cls.Field.PORT_ID])
tradegood_id = JsonTool.down(item, ["_id", cls.Field.TRADEGOOD_ID])
price = {MarketpriceDoc.Field.PORT: PortDoc.id2codename(port_id),
MarketpriceDoc.Field.TRADEGOOD: TradegoodDoc.id2codename(tradegood_id),
MarketpriceDoc.Field.RATE: int(item[cls.Field.RATE]),
MarketpriceDoc.Field.TREND: cls.trend_int2trend_price(item[cls.Field.TREND]),
}
return price
def item2doc(item):
port_codename = JsonTool.down(item, ["_id", cls.Field.PORT])
tradegood_codename = JsonTool.down(item, ["_id", cls.Field.TRADEGOOD])
price = merge_dicts([DictTool.keys2filtered(item, fields_others, ),
{cls.Field.PORT: port_codename,
cls.Field.TRADEGOOD: tradegood_codename,
},
], vwrite=vwrite_no_duplicate_key
)
return price
def test_04(self):
logger = FoxylibLogger.func_level2logger(self.test_04, logging.DEBUG)
channel = "C014DTPM24V"
headers = {"Content-type": 'application/json',
"Authorization": "Bearer {}".format(FoxylibSlack.xoxb_token()),
}
json1 = {"channel": channel,
"text": "Hello world :tada:",
}
response1 = requests.post("https://slack.com/api/chat.postMessage",
headers=headers,
json=json1)
self.assertEqual(response1.status_code, requests.codes.ok)
j1 = response1.json()
self.assertTrue(j1.get("ok"), j1)
ts = JsonTool.down(j1, ["message", "ts"])
json2 = {"channel": channel,
"ts": ts,
}
response2 = requests.post("https://slack.com/api/chat.delete",
headers=headers,
json=json2)
self.assertEqual(response2.status_code, requests.codes.ok)
j2 = response2.json()
self.assertTrue(j2.get("ok"), j2)
def marketprice_doc_iter(cls):
logger = HenriqueLogger.func_level2logger(cls.marketprice_doc_iter,
logging.DEBUG)
# h_id2culture = CultureTable.dict_id2codename()
# logger.debug({"h_id2culture":h_id2culture})
with HenriquePostgres.cursor() as cursor:
sql = SQL("SELECT * FROM {} ORDER BY id ASC").format(
Identifier(cls.NAME), )
cursor.execute(sql)
for t in PostgresTool.fetch_iter(cursor):
port_codename = cls.tuple2port_name_en(t)
tradegood_codename = cls.tuple2tradegood_name_en(t)
rate = cls.tuple2rate(t)
trend = Trend.int2trend(cls.tuple2trend(t))
data = cls.tuple2j(t)
server_codename = JsonTool.down(data, ["server"])
doc = {
MarketpriceDoc.Field.PORT: port_codename,
MarketpriceDoc.Field.TRADEGOOD: tradegood_codename,
MarketpriceDoc.Field.RATE: rate,
MarketpriceDoc.Field.TREND: trend,
MarketpriceDoc.Field.SERVER: server_codename,
# MarketpriceDoc.Field.CHATROOM_USER: channel_user,
}
yield doc
def codename2texts(codename):
for lang in langs:
aliases = JsonTool.down(h_lang2codename2aliases, [lang, codename])
if not aliases:
continue
yield from aliases
def env2ip(cls, env):
logger = HenriqueLogger.func_level2logger(cls.env2ip, logging.DEBUG)
j_server = cls.j_server()
# logger.debug({"j_server":j_server})
ip = JsonTool.down(j_server, [cls.Constant.ROOT, env, "ip"])
#logger.debug({"[cls.Constant.ROOT,env,ip]":[cls.Constant.ROOT,env,"ip"]})
return ip
def v_unit_lang2str(cls, v, unit, lang):
j_yaml = cls.yaml()
str_unit = JsonTool.down(j_yaml, [unit, lang])[0]
if lang in {"en"}:
return " ".join([str(v), str_unit])
if lang in {"ko"}:
return "".join([str(v), str_unit])
raise Exception("Invalid language: {}".format(lang))
def j_response2norm(cls, j_response):
jpath_list_exclusive = lmap(lambda s: s.split("."),
["file.id",
"file.created",
"file.timestamp",
"file.url_private",
"file.url_private_download",
"file.permalink",
"file.permalink_public",
"file.edit_link",
"file.preview",
"file.preview_highlight",
"file.shares.public",
])
return JsonTool.j_jpaths2excluded(j_response, jpath_list_exclusive)
def test_01(self):
logger = HenriqueLogger.func_level2logger(self.test_01, logging.DEBUG)
response1 = ErrorsChannel.post("testing...")
self.assertEqual(response1.status_code, requests.codes.ok, response1)
j1 = response1.json()
# logger.debug({"j1":j1})
self.assertTrue(j1.get("ok"), response1.content)
ts = JsonTool.down(j1, ["message", "ts"])
response2 = ErrorsChannel.delete(ts)
self.assertEqual(response2.status_code, requests.codes.ok, response2)
j2 = response2.json()
self.assertTrue(j2.get("ok"), response2.content)
def j_iter2mongodb(cls, j_iter, chunk_size=100000):
logger = HenriqueLogger.func_level2logger(cls.j_iter2mongodb,
logging.DEBUG)
j_list = list(j_iter)
n = len(j_list)
logger.debug({"n": n})
write_concern = WriteConcern(w=3, wtimeout=chunk_size)
collection = PortCollection.collection().with_options(
write_concern=write_concern)
for i, j_list_chunk in enumerate(
ChunkTool.chunk_size2chunks(j_list, chunk_size)):
logger.debug({"i/n": "{}/{}".format(i * chunk_size, n)})
j_pair_list = [(JsonTool.j_jpaths2filtered(j,
[[PortDoc.F.KEY]]), j)
for j in j_list_chunk]
MongoDBTool.j_pair_list2upsert(collection, j_pair_list)
def port_lang2aliases(cls, port, lang):
return JsonTool.down(port, [cls.Field.ALIASES, lang])
def tuple2tradegood_name_en(cls, t):
return JsonTool.down(cls.tuple2j(t),
["market_status", "tradegood", "name", "en"])
def port_lang2comments(cls, port, lang):
return JsonTool.down(port, [cls.Field.COMMENTS, lang])
def codename_lang2text(cls, codename, lang):
return JsonTool.down(cls.yaml(), [codename, lang])
def tuple2trend(cls, t):
trend = JsonTool.down(cls.tuple2j(t),
["market_status", "trend", "value"])
return trend - 2
def str_timedelta2relativetimedelta(cls, str_timedelta, lang):
suffix_format = JsonTool.down(cls.yaml(), [cls.Key.SUFFIX, lang])
return suffix_format.format(str_timedelta)
def data_lang2aliases_en(cls, data, lang):
name_en = JsonTool.down(data, ["name", lang])
nicknames_en = JsonTool.down(data, ["nicknames", lang]) or []
return luniq(chain([name_en], nicknames_en))
def tuple2chatuser_uuid(cls, t):
return JsonTool.down(cls.tuple2j(t), ["chatuser", "uuid"])
def tuple2port_name_en(cls, t):
return JsonTool.down(cls.tuple2j(t),
["market_status", "port", "name", "en"])
def culture_lang2aliases(cls, culture, lang):
logger = HenriqueLogger.func_level2logger(cls.culture_lang2aliases, logging.DEBUG)
aliases = JsonTool.down(culture, [cls.Field.ALIASES, lang])
# logger.debug({"culture": culture, "lang": lang, "aliases": aliases})
return aliases
def item2message(cls, item):
msg = JsonTool.down(item,
["snippet", "textMessageDetails", "messageText"])
return msg
def document2text(cls, document):
return GoogledocsElement.read_strucutural_elements(
JsonTool.down(document, ["body", "content"]))
def lang2str_idk(cls, lang):
return JsonTool.down(cls.yaml(), [cls.Key.I_DONT_KNOW, lang])
def tradegood_lang2aliases(cls, tradegood, lang):
return JsonTool.down(tradegood, [cls.Field.ALIASES, lang])
def server_lang2aliases(cls, server, lang):
return JsonTool.down(server, [cls.Field.ALIASES, lang]) or []
def tuple2rate(cls, t):
return JsonTool.down(cls.tuple2j(t), ["market_status", "rate"])
def doc_lang2names(cls, doc, lang):
names = JsonTool.down(doc, [cls.Field.NAMES, lang]) or []
return names