| from typing import List, Dict, Optional, Tuple |
| import random |
| import difflib |
| from rapidfuzz import fuzz |
| import sqlite3 |
| import functools |
| from const import KNOWLEDGE_TO_SELECT, UTTERANCE, ROLES, BELIEF_STATE, DOMAIN |
|
|
|
|
| def None_knowledge(): |
| return "None" |
|
|
|
|
| def concat_list_knowledge_wrapper(prompt: str = "", sep: str = " | "): |
| def get_list_knowledge(str_list: List[str]): |
| return prompt + sep.join(str_list) |
|
|
| return get_list_knowledge |
|
|
|
|
| def origin_knowledge(knowledge): |
| return knowledge |
|
|
|
|
| def extract_turn_knowledge( |
| knowledge, section_prompt_op, section_sep, section_value_sep |
| ): |
| if isinstance(knowledge, dict): |
| sec_list = [] |
| for section in sorted(knowledge.keys()): |
| sec_str = f"{section}{section_prompt_op}" |
| if isinstance(knowledge[section], str): |
| sec_str += knowledge[section] |
| elif isinstance(knowledge[section], list): |
| sec_str += section_value_sep.join(knowledge[section]) |
| sec_list.append(sec_str) |
|
|
| return section_sep.join(sec_list) |
|
|
| elif isinstance(knowledge, str): |
| return knowledge |
|
|
| elif isinstance(knowledge, list): |
| return ";; ".join( |
| [ |
| extract_turn_knowledge( |
| sec, section_prompt_op, section_sep, section_value_sep |
| ) |
| for sec in knowledge |
| ] |
| ) |
|
|
|
|
| def extract_turn_domains_wrapper(prompt: str = "", sep: str = ", "): |
| def extract_turn_domains(knowledge, turn): |
| bs = turn[BELIEF_STATE] |
| domains = [] |
| for state in bs: |
| domain = state[DOMAIN] |
| if domain not in domains: |
| domains.append(domain) |
|
|
| return prompt + sep.join(domains) |
|
|
| return extract_turn_domains |
|
|
|
|
| def extract_turn_knowledge_wrapper(section_prompt_op, section_sep, section_value_sep): |
| def extract_turn_knowledge_func(knowledge, turn): |
| return extract_turn_knowledge( |
| [knowledge[sec] for sec in turn[KNOWLEDGE_TO_SELECT]], |
| section_prompt_op, |
| section_sep, |
| section_value_sep, |
| ) |
|
|
| return extract_turn_knowledge_func |
|
|
|
|
| |
| EXIST = {"atis", "geo", "advising", "yelp", "restaurants", "imdb", "academic"} |
|
|
| |
| _stopwords = {'who', 'ourselves', 'down', 'only', 'were', 'him', 'at', "weren't", 'has', 'few', "it's", 'm', 'again', |
| 'd', 'haven', 'been', 'other', 'we', 'an', 'own', 'doing', 'ma', 'hers', 'all', "haven't", 'in', 'but', |
| "shouldn't", 'does', 'out', 'aren', 'you', "you'd", 'himself', "isn't", 'most', 'y', 'below', 'is', |
| "wasn't", 'hasn', 'them', 'wouldn', 'against', 'this', 'about', 'there', 'don', "that'll", 'a', 'being', |
| 'with', 'your', 'theirs', 'its', 'any', 'why', 'now', 'during', 'weren', 'if', 'should', 'those', 'be', |
| 'they', 'o', 't', 'of', 'or', 'me', 'i', 'some', 'her', 'do', 'will', 'yours', 'for', 'mightn', 'nor', |
| 'needn', 'the', 'until', "couldn't", 'he', 'which', 'yourself', 'to', "needn't", "you're", 'because', |
| 'their', 'where', 'it', "didn't", 've', 'whom', "should've", 'can', "shan't", 'on', 'had', 'have', |
| 'myself', 'am', "don't", 'under', 'was', "won't", 'these', 'so', 'as', 'after', 'above', 'each', 'ours', |
| 'hadn', 'having', 'wasn', 's', 'doesn', "hadn't", 'than', 'by', 'that', 'both', 'herself', 'his', |
| "wouldn't", 'into', "doesn't", 'before', 'my', 'won', 'more', 'are', 'through', 'same', 'how', 'what', |
| 'over', 'll', 'yourselves', 'up', 'mustn', "mustn't", "she's", 're', 'such', 'didn', "you'll", 'shan', |
| 'when', "you've", 'themselves', "mightn't", 'she', 'from', 'isn', 'ain', 'between', 'once', 'here', |
| 'shouldn', 'our', 'and', 'not', 'too', 'very', 'further', 'while', 'off', 'couldn', "hasn't", 'itself', |
| 'then', 'did', 'just', "aren't"} |
| |
|
|
| _commonwords = {"no", "yes", "many"} |
|
|
|
|
| def is_number(s: str) -> bool: |
| try: |
| float(s.replace(",", "")) |
| return True |
| except: |
| return False |
|
|
|
|
| def is_stopword(s: str) -> bool: |
| return s.strip() in _stopwords |
|
|
|
|
| def is_commonword(s: str) -> bool: |
| return s.strip() in _commonwords |
|
|
|
|
| def is_common_db_term(s: str) -> bool: |
| return s.strip() in ["id"] |
|
|
|
|
| class Match(object): |
| def __init__(self, start: int, size: int) -> None: |
| self.start = start |
| self.size = size |
|
|
|
|
| def is_span_separator(c: str) -> bool: |
| return c in "'\"()`,.?! " |
|
|
|
|
| def split(s: str) -> List[str]: |
| return [c.lower() for c in s.strip()] |
|
|
|
|
| def prefix_match(s1: str, s2: str) -> bool: |
| i, j = 0, 0 |
| for i in range(len(s1)): |
| if not is_span_separator(s1[i]): |
| break |
| for j in range(len(s2)): |
| if not is_span_separator(s2[j]): |
| break |
| if i < len(s1) and j < len(s2): |
| return s1[i] == s2[j] |
| elif i >= len(s1) and j >= len(s2): |
| return True |
| else: |
| return False |
|
|
|
|
| def get_effective_match_source(s: str, start: int, end: int) -> Match: |
| _start = -1 |
|
|
| for i in range(start, start - 2, -1): |
| if i < 0: |
| _start = i + 1 |
| break |
| if is_span_separator(s[i]): |
| _start = i |
| break |
|
|
| if _start < 0: |
| return None |
|
|
| _end = -1 |
| for i in range(end - 1, end + 3): |
| if i >= len(s): |
| _end = i - 1 |
| break |
| if is_span_separator(s[i]): |
| _end = i |
| break |
|
|
| if _end < 0: |
| return None |
|
|
| while _start < len(s) and is_span_separator(s[_start]): |
| _start += 1 |
| while _end >= 0 and is_span_separator(s[_end]): |
| _end -= 1 |
|
|
| return Match(_start, _end - _start + 1) |
|
|
|
|
| def get_matched_entries( |
| s: str, field_values: List[str], m_theta: float = 0.85, s_theta: float = 0.85 |
| ) -> Optional[List[Tuple[str, Tuple[str, str, float, float, int]]]]: |
| if not field_values: |
| return None |
|
|
| if isinstance(s, str): |
| n_grams = split(s) |
| else: |
| n_grams = s |
|
|
| matched = dict() |
| for field_value in field_values: |
| if not isinstance(field_value, str): |
| continue |
| fv_tokens = split(field_value) |
| sm = difflib.SequenceMatcher(None, n_grams, fv_tokens) |
| match = sm.find_longest_match(0, len(n_grams), 0, len(fv_tokens)) |
| if match.size > 0: |
| source_match = get_effective_match_source( |
| n_grams, match.a, match.a + match.size |
| ) |
| if source_match and source_match.size > 1: |
| match_str = field_value[match.b : match.b + match.size] |
| source_match_str = s[ |
| source_match.start : source_match.start + source_match.size |
| ] |
| c_match_str = match_str.lower().strip() |
| c_source_match_str = source_match_str.lower().strip() |
| c_field_value = field_value.lower().strip() |
| if ( |
| c_match_str |
| and not is_number(c_match_str) |
| and not is_common_db_term(c_match_str) |
| ): |
| if ( |
| is_stopword(c_match_str) |
| or is_stopword(c_source_match_str) |
| or is_stopword(c_field_value) |
| ): |
| continue |
| if c_source_match_str.endswith(c_match_str + "'s"): |
| match_score = 1.0 |
| else: |
| if prefix_match(c_field_value, c_source_match_str): |
| match_score = ( |
| fuzz.ratio(c_field_value, c_source_match_str) / 100 |
| ) |
| else: |
| match_score = 0 |
| if ( |
| is_commonword(c_match_str) |
| or is_commonword(c_source_match_str) |
| or is_commonword(c_field_value) |
| ) and match_score < 1: |
| continue |
| s_match_score = match_score |
| if match_score >= m_theta and s_match_score >= s_theta: |
| if field_value.isupper() and match_score * s_match_score < 1: |
| continue |
| matched[match_str] = ( |
| field_value, |
| source_match_str, |
| match_score, |
| s_match_score, |
| match.size, |
| ) |
|
|
| if not matched: |
| return None |
| else: |
| return sorted( |
| matched.items(), |
| key=lambda x: (1e16 * x[1][2] + 1e8 * x[1][3] + x[1][4]), |
| reverse=True, |
| ) |
|
|
|
|
| @functools.lru_cache(maxsize=1000, typed=False) |
| def get_column_picklist(table_name: str, column_name: str, db_path: str) -> list: |
| fetch_sql = "SELECT DISTINCT `{}` FROM `{}`".format(column_name, table_name) |
| try: |
| conn = sqlite3.connect(db_path) |
| conn.text_factory = bytes |
| c = conn.cursor() |
| c.execute(fetch_sql) |
| picklist = set() |
| for x in c.fetchall(): |
| if isinstance(x[0], str): |
| picklist.add(x[0].encode("utf-8")) |
| elif isinstance(x[0], bytes): |
| try: |
| picklist.add(x[0].decode("utf-8")) |
| except UnicodeDecodeError: |
| picklist.add(x[0].decode("latin-1")) |
| else: |
| picklist.add(x[0]) |
| picklist = list(picklist) |
| finally: |
| conn.close() |
| return picklist |
|
|
|
|
| def get_database_matches( |
| question: str, |
| table_name: str, |
| column_name: str, |
| db_path: str, |
| top_k_matches: int = 2, |
| match_threshold: float = 0.85, |
| ) -> List[str]: |
| picklist = get_column_picklist( |
| table_name=table_name, column_name=column_name, db_path=db_path |
| ) |
| matches = [] |
| if picklist and isinstance(picklist[0], str): |
| matched_entries = get_matched_entries( |
| s=question, |
| field_values=picklist, |
| m_theta=match_threshold, |
| s_theta=match_threshold, |
| ) |
| if matched_entries: |
| num_values_inserted = 0 |
| for _match_str, ( |
| field_value, |
| _s_match_str, |
| match_score, |
| s_match_score, |
| _match_size, |
| ) in matched_entries: |
| if "name" in column_name and match_score * s_match_score < 1: |
| continue |
| if table_name != "sqlite_sequence": |
| matches.append(field_value) |
| num_values_inserted += 1 |
| if num_values_inserted >= top_k_matches: |
| break |
| return matches |
|
|
|
|
| def serialize_schema( |
| question: str, |
| db_path: str, |
| db_id: str, |
| db_column_names: Dict[str, str], |
| db_table_names: List[str], |
| schema_serialization_type: str = "peteshaw", |
| schema_serialization_randomized: bool = False, |
| schema_serialization_with_db_id: bool = True, |
| schema_serialization_with_db_content: bool = False, |
| normalize_query: bool = True, |
| ) -> str: |
| if schema_serialization_type == "verbose": |
| db_id_str = "Database: {db_id}. " |
| table_sep = ". " |
| table_str = "Table: {table}. Columns: {columns}" |
| column_sep = ", " |
| column_str_with_values = "{column} ({values})" |
| column_str_without_values = "{column}" |
| value_sep = ", " |
| elif schema_serialization_type == "peteshaw": |
| |
| db_id_str = "{db_id}" |
| table_sep = "" |
| table_str = " | {table} : {columns}" |
| column_sep = " , " |
| column_str_with_values = "{column} ( {values} )" |
| column_str_without_values = "{column}" |
| value_sep = " , " |
| else: |
| raise NotImplementedError |
|
|
| def get_column_str(table_name: str, column_name: str) -> str: |
| column_name_str = column_name.lower() if normalize_query else column_name |
| if schema_serialization_with_db_content: |
| matches = get_database_matches( |
| question=question, |
| table_name=table_name, |
| column_name=column_name, |
| db_path=(db_path + "/" + db_id + "/" + db_id + ".sqlite"), |
| ) |
| if matches: |
| return column_str_with_values.format( |
| column=column_name_str, values=value_sep.join(matches) |
| ) |
| else: |
| return column_str_without_values.format(column=column_name_str) |
| else: |
| return column_str_without_values.format(column=column_name_str) |
|
|
| tables = [ |
| table_str.format( |
| table=table_name.lower() if normalize_query else table_name, |
| columns=column_sep.join( |
| map( |
| lambda y: get_column_str(table_name=table_name, column_name=y[1]), |
| filter( |
| lambda y: y[0] == table_id, |
| zip( |
| db_column_names["table_id"], |
| db_column_names["column_name"], |
| ), |
| ), |
| ) |
| ), |
| ) |
| for table_id, table_name in enumerate(db_table_names) |
| ] |
| if schema_serialization_randomized: |
| random.shuffle(tables) |
| if schema_serialization_with_db_id: |
| serialized_schema = db_id_str.format(db_id=db_id) + table_sep.join(tables) |
| else: |
| serialized_schema = table_sep.join(tables) |
| return serialized_schema |
|
|
|
|
| def extract_schema_knowledge_wrapper( |
| schema_serialization_type: str = "peteshaw", |
| schema_serialization_randomized: bool = False, |
| schema_serialization_with_db_id: bool = True, |
| schema_serialization_with_db_content: bool = False, |
| normalize_query: bool = True, |
| ): |
| def extract_turn_schema_knowledge_func(knowledge, turn): |
| schema = knowledge["schema"] |
| db_column_names = { |
| "table_id": [table_id for table_id, _ in schema["column_names_original"]], |
| "column_name": [ |
| column_name for _, column_name in schema["column_names_original"] |
| ], |
| } |
| return serialize_schema( |
| turn[UTTERANCE], |
| knowledge["db_path"], |
| knowledge["db_id"], |
| db_column_names, |
| schema["table_names_original"], |
| schema_serialization_type, |
| schema_serialization_randomized, |
| schema_serialization_with_db_id, |
| schema_serialization_with_db_content, |
| normalize_query, |
| ) |
|
|
| return extract_turn_schema_knowledge_func |
|
|
|
|
| def extract_dict_knowledge(knowledge, key_prompt_op, pair_sep): |
| pair_list = [] |
| for key in knowledge: |
| pair_list.append(f"{key}{key_prompt_op}{knowledge[key]}") |
|
|
| if not pair_list: |
| return "None" |
|
|
| return pair_sep.join(pair_list) |
|
|
|
|
| def extract_dict_knowledge_wrapper(key_prompt_op, pair_sep): |
| def extract_dict_knowledge_func(knowledge): |
| return extract_dict_knowledge(knowledge, key_prompt_op, pair_sep) |
|
|
| return extract_dict_knowledge_func |
|
|
|
|
| def extract_dialogue_knowledge(knowledge, key_prompt_op, pair_sep, role_sep): |
| pair_list = [] |
| for key in knowledge: |
| if isinstance(knowledge[key], str): |
| pair_list.append(f"{key}{key_prompt_op}{knowledge[key]}") |
| elif isinstance(knowledge[key], list): |
| turns = [] |
| for turn in knowledge[key]: |
| role_str = role_sep.join(turn[ROLES]) |
| turns.append(f"{role_str}# {turn[UTTERANCE]}") |
| dial_str = " ".join(turns) |
| pair_list.append(f"{key}{key_prompt_op}{dial_str}") |
| if not pair_list: |
| return "None" |
| return pair_sep.join(pair_list) |
|
|
|
|
| def extract_dialogue_knowledge_wrapper(key_prompt_op, pair_sep, role_sep): |
| def extract_dialogue_knowledge_func(knowledge): |
| return extract_dialogue_knowledge(knowledge, key_prompt_op, pair_sep, role_sep) |
|
|
| return extract_dialogue_knowledge_func |
|
|
|
|
| def extract_kg_knowledge( |
| knowledge, key_prompt_op, pair_sep, intra_edge_sep, inner_edge_sep |
| ): |
| pair_list = [] |
| for key in knowledge: |
| if isinstance(knowledge[key], str): |
| pair_list.append(f"{key}{key_prompt_op}{knowledge[key]}") |
| elif isinstance(knowledge[key], list): |
| edges = [] |
| for edge in knowledge[key]: |
| edges.append(inner_edge_sep.join(edge)) |
| kg_str = intra_edge_sep.join(edges) |
| pair_list.append(f"{key}{key_prompt_op}{kg_str}") |
| if not pair_list: |
| return "None" |
| return pair_sep.join(pair_list) |
|
|
|
|
| def extract_kg_knowledge_wrapper( |
| key_prompt_op, pair_sep, intra_edge_sep, inner_edge_sep |
| ): |
| def extract_kg_knowledge_func(knowledge): |
| return extract_kg_knowledge( |
| knowledge, key_prompt_op, pair_sep, intra_edge_sep, inner_edge_sep |
| ) |
|
|
| return extract_kg_knowledge_func |
|
|
