
import argparse
import logging
import pickle
from collections import Counter


logging.basicConfig(
    format='''%(asctime)s - %(levelname)s - %(name)s - %(message)s''', datefmt='''%m/%d/%Y %H:%M:%S''', level=logging.INFO
)
A		: str								=     logging.getLogger(__name__)

if __name__ == "__main__":
		A		: str								=     argparse.ArgumentParser(
		    description='''Token Counts for smoothing the masking probabilities in MLM (cf XLM/word2vec)'''
		)
		parser.add_argument(
		    '''--data_file''', type=str, default='''data/dump.bert-base-uncased.pickle''', help='''The binarized dataset.'''
		)
		parser.add_argument(
		    '''--token_counts_dump''', type=str, default='''data/token_counts.bert-base-uncased.pickle''', help='''The dump file.'''
		)
		parser.add_argument('''--vocab_size''', default=30_522, type=int)
		A		: str								=     parser.parse_args()

		logger.info(F'Loading data from {args.data_file}')
		with open(args.data_file, '''rb''') as fp:
				A		: List[str]								=     pickle.load(fp)

		logger.info('''Counting occurrences for MLM.''')
		A		: List[Any]								=     Counter()
		for tk_ids in data:
				counter.update(tk_ids)
		A		: Any								=     [0] * args.vocab_size
		for k, v in counter.items():
				A		: List[Any]								=     v

		logger.info(F'Dump to {args.token_counts_dump}')
		with open(args.token_counts_dump, '''wb''') as handle:
				pickle.dump(counts, handle, protocol=pickle.HIGHEST_PROTOCOL)

def 	UpperCamelCase__  (     SCREAMING_SNAKE_CASE_	:	int       )  ->     list:

						# bit count represents no. of bits in the gray code
						if bit_count < 0:
												raise ValueError("""The given input must be positive"""       )

						# get the generated string sequence
						_lowercase					       =					gray_code_sequence_string(SCREAMING_SNAKE_CASE_       )
						#
						# convert them to integers
						for i in range(len(SCREAMING_SNAKE_CASE_       )       ):
												_lowercase					       =					int(sequence[i]		,   2       )

						return sequence




def 	UpperCamelCase__  (     SCREAMING_SNAKE_CASE_	:	int       )  ->     list:

						# The approach is a recursive one
						# Base case achieved when either n = 0 or n=1
						if bit_count == 0:
												return ["0"]

						if bit_count == 1:
												return ["0", "1"]

						_lowercase					       =					1 << bit_count  # defines the length of the sequence
						# 1<< n is equivalent to 2^n

						# recursive answer will generate answer for n-1 bits
						_lowercase					       =					gray_code_sequence_string(bit_count - 1       )

						_lowercase					       =					[]

						# append 0 to first half of the smaller sequence generated
						for i in range(seq_len // 2       ):
												_lowercase					       =					"""0""" + smaller_sequence[i]
												sequence.append(SCREAMING_SNAKE_CASE_       )

						# append 1 to second half ... start from the end of the list
						for i in reversed(range(seq_len // 2       )       ):
												_lowercase					       =					"""1""" + smaller_sequence[i]
												sequence.append(SCREAMING_SNAKE_CASE_       )

						return sequence


if __name__ == "__main__":
		import doctest

		doctest.testmod()