def _rootname_list(cls):
return luniq(
chain(
FoxylibLogger.rootname_list(),
KhalaLogger.rootname_list(),
[cls.ROOTNAME],
))
def entity_list2codename_list(entity_list):
codename_list = luniq(
map(SkillEntity.entity2skill_codename, entity_list))
if codename_list:
return codename_list
return [HenriqueSkill.Codename.HELP]
def postgres2j_iter(cls):
logger = HenriqueLogger.func_level2logger(cls.postgres2j_iter,
logging.DEBUG)
with HenriquePostgres.cursor() as cursor:
sql = SQL("SELECT * from {}").format(
Identifier(TradegoodTable.NAME))
cursor.execute(sql)
for t in PostgresTool.fetch_iter(cursor):
j = t[TradegoodTable.index_json()]
# logger.debug({"j":j})
h_lang2names = {}
for lang, name in j["name"].items():
h_lang2names[lang] = lchain(h_lang2names.get(lang, []),
[name])
for lang, nickname_list in j.get("nicknames", {}).items():
h_lang2names[lang] = lchain(h_lang2names.get(lang, []),
nickname_list)
j[TradegoodDoc.F.NAMES] = {
lang: luniq(name_list)
for lang, name_list in h_lang2names.items()
}
for k in ["name", "nicknames"]:
j.pop(k, None)
# logger.debug({'j["names"]':j["names"]})
j[TradegoodDoc.F.KEY] = j["names"]["en"][0]
yield j
def tradegoodtype_list_all(cls):
h_codename2aliases_en = NamesenSheet.dict_codename2aliases()
h_codename2aliases_ko = NameskoSheet.dict_codename2aliases()
h_codename2category = CategorySheet.dict_codename2tradegoodtype()
# raise Exception({"h_codename2product_list":h_codename2product_list})
codename_list = luniq(
chain(
h_codename2aliases_en.keys(),
h_codename2aliases_ko.keys(),
))
def codename2port(codename):
aliases = DictTool.filter(
lambda k, v: v, {
"en": h_codename2aliases_en.get(codename),
"ko": h_codename2aliases_ko.get(codename),
})
category = h_codename2category.get(codename)
port = DictTool.filter(
lambda k, v: bool(v), {
Tradegoodtype.Field.CODENAME: codename,
Tradegoodtype.Field.CATEGORY: category,
Tradegoodtype.Field.ALIASES: aliases,
})
return DictTool.filter(lambda k, v: v, port)
return lmap(codename2port, codename_list)
def culture_list_all(cls):
logger = HenriqueLogger.func_level2logger(cls.culture_list_all,
logging.DEBUG)
h_codename2aliases_en = NamesenSheet.dict_codename2aliases()
h_codename2aliases_ko = NameskoSheet.dict_codename2aliases()
h_codename2prefers = PrefersSheet.dict_codename2prefers()
codename_list = luniq(
chain(
h_codename2aliases_en.keys(),
h_codename2aliases_ko.keys(),
h_codename2prefers.keys(),
))
def codename2culture(codename):
aliases = DictTool.filter(
lambda k, v: v, {
"en": h_codename2aliases_en.get(codename),
"ko": h_codename2aliases_ko.get(codename),
})
culture = {
Culture.Field.CODENAME: codename,
Culture.Field.ALIASES: aliases,
Culture.Field.PREFERS: h_codename2prefers.get(codename) or [],
}
return DictTool.filter(lambda k, v: v, culture)
list_all = lmap(codename2culture, codename_list)
# logger.debug({"list_all":list_all})
return list_all
def port_list_all(cls):
h_codename2aliases_en = NamesenSheet.dict_codename2aliases()
h_codename2aliases_ko = NameskoSheet.dict_codename2aliases()
h_codename2culture = CultureSheet.dict_codename2culture()
h_codename2product_list = ProductSheet.dict_codename2products()
h_codename2comments_ko = CommentsKoSheet.dict_codename2comments()
# raise Exception({"h_codename2product_list":h_codename2product_list})
codename_list = luniq(chain(h_codename2aliases_en.keys(),
h_codename2aliases_ko.keys(),
)
)
def codename2port(codename):
aliases = DictTool.filter(lambda k, v: v,
{"en": h_codename2aliases_en.get(codename),
"ko": h_codename2aliases_ko.get(codename),
})
comments = DictTool.filter(lambda k, v: v,
{"ko": h_codename2comments_ko.get(codename),
})
port = {Port.Field.CODENAME: codename,
Port.Field.CULTURE: h_codename2culture[codename],
Port.Field.ALIASES: aliases,
Port.Field.PRODUCTS: h_codename2product_list.get(codename),
Port.Field.COMMENTS: comments,
}
return DictTool.filter(lambda k, v: v, port)
return lmap(codename2port, codename_list)
def dict_codename2aliases(cls):
data_ll = ChatroomuserGooglesheets.sheetname2data_ll(cls.NAME)
h = merge_dicts([{
row[0]: luniq(row)
} for row in data_ll[1:]],
vwrite=vwrite_no_duplicate_key)
return h
def upsert_channel_user():
channel_user_list_raw = lfilter(is_not_none, map(ig(1), pair_list))
logger.debug({"len(channel_user_list_raw)": len(channel_user_list_raw)})
# raise Exception({"channel_user_list_raw[0]": channel_user_list_raw[0]})
channel_user_list = luniq(channel_user_list_raw, idfun=ChannelUser.channel_user2codename)
collection = ChannelUserCollection.collection().with_options(write_concern=write_concern)
def doc2pair(channel_user):
cond = {ChannelUser.Field.CODENAME: ChannelUser.channel_user2codename(channel_user)}
return cond, channel_user
j_pair_list = lmap(doc2pair, channel_user_list)
MongoDBTool.j_pair_list2upsert(collection, j_pair_list)
def str_list2j_row(cls, j_colhead_list, str_list_ROW):
if len(j_colhead_list) != len(str_list_ROW):
return None # Invalid line
n_col = len(j_colhead_list)
k_list_valid = lfilter(lambda k: str_list_ROW[k], range(n_col))
j_cells = luniq([
GSSTool.Cell.parse_str2j(j_colhead_list[k], str_list_ROW[k])
for k in k_list_valid
],
idfun=GSSTool.Cell.j2key)
# j_row = merge_dicts([{cls.ATTRNAME_CELLS:j_cells},
# ], vwrite=vwrite_no_duplicate_key)
return j_cells
def codename_lang2text(cls, port_codename, lang):
logger = HenriqueLogger.func_level2logger(cls.codename_lang2text,
logging.DEBUG)
port = Port.codename2port(port_codename)
culture = Culture.codename2culture(Port.port2culture(port))
tgt_codenames = luniq(
filter(
bool,
map(Product.product2tradegoodtype,
Product.port2products(port_codename))))
tradegoodtype_list = sorted(map(Tradegoodtype.codename2tradegoodtype,
tgt_codenames),
key=Tradegoodtype.key)
def tgt_list2text_resistant(tgt_list):
logger.debug({"tgt_list": tgt_list})
if not tgt_list:
return None
return ", ".join([
Tradegoodtype.tradegoodtype_lang2name(tgt, lang)
for tgt in tgt_list
])
tradegoodtypes_resistant = tgt_list2text_resistant(tradegoodtype_list)
comments = Port.port_lang2comments(port, lang)
comment = choice(comments) if comments else None
filepath = os.path.join(FILE_DIR, "tmplt.{}.part.txt".format(lang))
data = {
"name": Port.port_lang2name(port, lang),
"culture": Culture.culture_lang2name(culture, lang),
"tradegoodtypes_resistant": tradegoodtypes_resistant,
"comment": comment,
}
text_out = str2strip(HenriqueJinja2.textfile2text(filepath, data))
return text_out
def text2entity_list(cls, str_in):
logger = FoxylibLogger.func_level2logger(cls.text2entity_list,
logging.DEBUG)
entity_list_single = DayofweekEntityKoSingle.text2entity_list(str_in)
entity_list_concat = DayofweekEntityKoConcat.text2entity_list(str_in)
ll = [
entity_list_single,
entity_list_concat,
]
l = sorted(luniq(chain(*ll), idfun=FoxylibEntity.entity2span),
key=FoxylibEntity.entity2span)
logger.debug({
"entity_list_single": entity_list_single,
"entity_list_concat": entity_list_concat,
"ll": ll,
"l": l,
})
return l
def server_list_all(cls):
h_codename2aliases_en = NamesenSheet.dict_codename2aliases()
h_codename2aliases_ko = NameskoSheet.dict_codename2aliases()
codename_list = luniq(
chain(
h_codename2aliases_en.keys(),
h_codename2aliases_ko.keys(),
))
def codename2server(codename):
aliases = DictTool.filter(
lambda k, v: v, {
"en": h_codename2aliases_en.get(codename),
"ko": h_codename2aliases_ko.get(codename),
})
culture = {
Server.Field.CODENAME: codename,
Server.Field.ALIASES: aliases,
}
return DictTool.filter(lambda k, v: v, culture)
return lmap(codename2server, codename_list)
def port_langs2aliases(cls, port, langs):
return luniq(chain(*[cls.port_lang2aliases(port, lang) for lang in langs]))
def tradegood_langs2aliases(cls, tradegood, langs):
return luniq(
chain(*[
cls.tradegood_lang2aliases(tradegood, lang) for lang in langs
]))
def server_langs2aliases(cls, server, langs):
return luniq(chain(*[cls.server_lang2aliases(server, lang) for lang in langs]))
def codename_lang2text(cls, tradegood_codename, lang):
logger = HenriqueLogger.func_level2logger(cls.codename_lang2text,
logging.DEBUG)
tradegood = Tradegood.codename2tradegood(tradegood_codename)
filepath = os.path.join(FILE_DIR, "tmplt.{}.part.txt".format(lang))
tgt_codename = Tradegood.tradegood2tradegoodtype(tradegood)
tgt = Tradegoodtype.codename2tradegoodtype(
tgt_codename) if tgt_codename else None
category = Tradegoodtype.tradegoodtype2category(tgt) if tgt else None
ports_selling = Port.tradegood2ports(tradegood_codename)
prefers = Prefer.tradegood2prefers(tradegood_codename)
# def prefers2cultures(prefers):
# culture_codenames = luniq(map(Prefer.prefer2culture, prefers))
# return lmap(Culture.codename2culture, culture_codenames)
culture_codenames_preferred = luniq(map(Prefer.prefer2culture,
prefers)) if prefers else []
# culture_list_preferred = prefers2cultures(prefers) if prefers else []
port_list_preferred = lchain(
*map(Port.culture2ports, culture_codenames_preferred))
def port2is_resistant(port):
if not tgt:
return False
products = Product.port2products(Port.port2codename(port))
tgt_codenames_port = smap(Product.product2tradegoodtype, products)
logger.debug({
"tgt": tgt,
"tgt_codenames_port": tgt_codenames_port
})
return Tradegoodtype.tradegoodtype2codename(
tgt) in tgt_codenames_port
port_list_preferred_resistant = lfilter(port2is_resistant,
port_list_preferred)
def ports2str(ports):
if not ports:
return None
return ", ".join(
[Port.port_lang2name(port, lang) for port in ports])
def culture_codenames2str(culture_codenames):
if not culture_codenames:
return None
logger.debug({"culture_codenames": culture_codenames})
cultures = lmap(Culture.codename2culture, culture_codenames)
return ", ".join([
Culture.culture_lang2name(culture, lang)
for culture in cultures
])
logger.debug(
{"culture_codenames_preferred": culture_codenames_preferred})
data = {
"name":
Tradegood.tradegood_lang2name(tradegood, lang),
"category":
Tradegoodcategory.tradegoodcategory2str(category)
if category else None,
"tradegoodtype":
Tradegoodtype.tradegoodtype_lang2name(tgt, lang) if tgt else None,
"ports_selling":
ports2str(ports_selling),
"cultures_preferred":
culture_codenames2str(culture_codenames_preferred),
"ports_preferred_resistant":
ports2str(port_list_preferred_resistant),
}
text_out = str2strip(HenriqueJinja2.textfile2text(filepath, data))
return text_out
def cliques2dict_tradegood2indexes(cls, clique_list):
tradegood_codename_list = luniq(
chain(*map(cls.clique2tradegoods, clique_list)))
h_tg2index = {tg: i for i, tg in enumerate(tradegood_codename_list)}
return h_tg2index
def cliques2dict_port2indexes(cls, clique_list):
port_codename_list = luniq(chain(*map(cls.clique2ports, clique_list)))
h_port2index = {p: i for i, p in enumerate(port_codename_list)}
return h_port2index
def culture_langs2aliases(cls, port, langs):
aliases_list = lfilter(bool, [cls.culture_lang2aliases(port, lang) for lang in langs])
return luniq(chain(*aliases_list))
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))
