# Copyright 2024 FBK # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # http://www.apache.org/licenses/LICENSE-2.0 # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License try: import pandas as pd except ImportError: print("Please install the pandas package with 'pip install pandas' and try again.") exit(1) import argparse _VERSION = "1.01" class ExplicitDefaultsHelpFormatter(argparse.ArgumentDefaultsHelpFormatter): def _get_help_string(self, action): if action.default is None or action.default is False: return action.help return super()._get_help_string(action) def processColumn(col, dict): # compute the counts of words that appear alone in the lines for line in col: if len(line.split()) == 1: key=line.strip() if key in dict: dict[key]+=1 else: dict[key]=1 def processTSVfiles(files, dict): # open and process textual content of each TSV file in the input list; # return the word with the greatest count for tsv in files: try: inDF = pd.read_csv(tsv, sep='\t', dtype=str, low_memory=False, na_filter=False, quoting=3) except IOError: print("Error in opening "+tsv+" file") try: col = inDF[parsed_args.column] except KeyError: print("Error in reading column <"+parsed_args.column+"> in TSV file") exit(1) processColumn(col, dict) return findSuspiciousWord(dict) def findSuspiciousWord(dict): # look for the word in dict with the greatest count argmax = "" max = -1 for w,c in list(dict.items()): if c > max: max = c argmax = w return argmax def main(args): """ This script flags (by setting True the corresponding entry of the hall_frequent_single_word) those sentences which consists of only one single suspicious word. This word can be either passed as a parameter (suspiciousWord option) or found inside the TSV input files. In the latter case, it is set as the most frequent word in the text included in files to be inspected. The TSV files to inspect can be passed through the tsv-SuspiciousWordFiles option. If no explicit suspiciousWord nor tsv-SuspiciousWordFiles is passed, the tsv-InFile is inspected. """ # Support structure: dict = {} if (parsed_args.version): print(f"Version {_VERSION} of anomalous string detector") exit(1) if not (tsv_files_specified): print("--tsv-InFile and --tsv-OutFile are both required") parser.print_usage() exit(1) if (contrastive_options): print("Either specify SuspiciousWord or SuspiciousWordFiles, both cannot be passed") parser.print_usage() exit(1) """ Get the suspiciousWord: """ if getattr(parsed_args, 'suspiciousWord') is not None: # passed as parameter suspiciousWord = parsed_args.suspiciousWord.strip() elif getattr(parsed_args, 'tsv_SuspiciousWordFiles') is not None: # to be searched in TSV files passed for that suspiciousWord = processTSVfiles(parsed_args.tsv_SuspiciousWordFiles, dict) else: # to be searched in the input TSV file to process suspiciousWord = processTSVfiles([parsed_args.tsv_InFile], dict) # open input TSV file and get the text to process try: inDF = pd.read_csv(args.tsv_InFile, sep='\t', dtype=str, low_memory=False, na_filter=False, quoting=3) except IOError: print("Error in opening "+tsv+" file") try: txt = inDF[parsed_args.column] except KeyError: print("Error in reading column <"+parsed_args.column+"> in TSV file") exit(1) # scan each input line and check if it consists of # only the suspicious word flag = [] for line in txt: if suspiciousWord == line.strip(): if args.quiet: flag.append("True") else: flag.append("True ("+suspiciousWord+")") else: flag.append("False") # add the column to the original Data Frame read from the input TSV file # and store the updated Data Frame in the output TSV file: inDF['hall_frequent_single_word'] = flag inDF.to_csv(args.tsv_OutFile, sep="\t", index=False, quoting=3) if __name__ == '__main__': parser = argparse.ArgumentParser(formatter_class=ExplicitDefaultsHelpFormatter) # I/O related arguments parser.add_argument( '--tsv-InFile', '-i', type=str, help="The input TSV file [Mandatory]") parser.add_argument( '--tsv-OutFile', '-o', type=str, help="The output TSV file [Mandatory. If equal to input TSV file, the new column ('suspicious single word') is added to the original file]") parser.add_argument( '--tsv-SuspiciousWordFiles', '-s', type=str, nargs='+', help="The TSV file(s) used to look for the suspicious word [Optional. If not present, the input TSV file is used instead]") # Processing arguments: parser.add_argument( '--column', '-c', default='source', help="Column name of the text to process [Optional]") parser.add_argument( '--suspiciousWord', '-w', type=str, help="suspicious word [if not specified, found in other TSV files passed as parameters]") # Reporting related arguments parser.add_argument( '--quiet', '-q', default=False, action='store_true', help='Print only True/False, no explanation for True\'s') # Get version information: parser.add_argument( '--version', '-v', action='store_true', default=False, help="Print version of the script and exit") parsed_args = parser.parse_args() tsv_files_specified = \ getattr(parsed_args, 'tsv_InFile') is not None \ and len(parsed_args.tsv_InFile) > 0 \ and getattr(parsed_args, 'tsv_OutFile') is not None \ and len(parsed_args.tsv_OutFile) > 0 contrastive_options = \ getattr(parsed_args, 'tsv_SuspiciousWordFiles') is not None \ and getattr(parsed_args, 'suspiciousWord') is not None main(parsed_args)