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))