Datasets:

FBK-MT
/

mosel

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