



"""simple docstring"""





import argparse
import json
import os

from tensorflow.core.protobuf.saved_model_pba import SavedModel


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_copies.py
__lowerCAmelCase							:       List[Any]          =       '''.'''

# Internal TensorFlow ops that can be safely ignored (mostly specific to a saved model)
__lowerCAmelCase							:       Optional[int]          =       [
    '''Assert''',
    '''AssignVariableOp''',
    '''EmptyTensorList''',
    '''MergeV2Checkpoints''',
    '''ReadVariableOp''',
    '''ResourceGather''',
    '''RestoreV2''',
    '''SaveV2''',
    '''ShardedFilename''',
    '''StatefulPartitionedCall''',
    '''StaticRegexFullMatch''',
    '''VarHandleOp''',
]
def 						__lowerCAmelCase    (		__UpperCamelCase   :      Union[str, Any]       ,			__UpperCamelCase   :      Any       ,			__UpperCamelCase   :      Union[str, Any]     ):


						'''simple docstring'''






						snake_case_ :			Any            =      SavedModel()
						snake_case_ :			str            =      []

						with open(os.path.join(__UpperCamelCase       ,			"""utils"""       ,			"""tf_ops"""       ,			"""onnx.json"""     )     ) as f:
												snake_case_ :			str            =      json.load(__UpperCamelCase     )["""opsets"""]

						for i in range(1       ,			opset + 1     ):
												onnx_ops.extend(onnx_opsets[str(__UpperCamelCase     )]     )

						with open(__UpperCamelCase       ,			"""rb"""     ) as f:
												saved_model.ParseFromString(f.read()     )

						snake_case_ :			Tuple            =      set()

						# Iterate over every metagraph in case there is more than one (a saved model can contain multiple graphs)
						for meta_graph in saved_model.meta_graphs:
												# Add operations in the graph definition
												model_op_names.update(node.op for node in meta_graph.graph_def.node     )

												# Go through the functions in the graph definition
												for func in meta_graph.graph_def.library.function:
																		# Add operations in each function
																		model_op_names.update(node.op for node in func.node_def     )

    # Convert to list, sorted if you want
						snake_case_ :			Optional[Any]            =      sorted(__UpperCamelCase     )
						snake_case_ :			Any            =      []

						for op in model_op_names:
												if op not in onnx_ops and op not in INTERNAL_OPS:
																		incompatible_ops.append(__UpperCamelCase     )

						if strict and len(__UpperCamelCase     ) > 0:
												raise Exception(F'Found the following incompatible ops for the opset {opset}:\n' + incompatible_ops     )
						elif len(__UpperCamelCase     ) > 0:
												print(F'Found the following incompatible ops for the opset {opset}:'     )
												print(*__UpperCamelCase       ,			sep="""\n"""     )
						else:
												print(F'The saved model {saved_model_path} can properly be converted with ONNX.'     )


if __name__ == "__main__":
					__lowerCAmelCase							:       Any          =       argparse.ArgumentParser()
					parser.add_argument('''--saved_model_path''', help='''Path of the saved model to check (the .pb file).''')
					parser.add_argument(
					    '''--opset''', default=12, type=int, help='''The ONNX opset against which the model has to be tested.'''
					)
					parser.add_argument(
					    '''--framework''', choices=['''onnx'''], default='''onnx''', help='''Frameworks against which to test the saved model.'''
					)
					parser.add_argument(
					    '''--strict''', action='''store_true''', help='''Whether make the checking strict (raise errors) or not (raise warnings)'''
					)
					__lowerCAmelCase							:       Tuple          =       parser.parse_args()

					if args.framework == "onnx":
										onnx_compliancy(args.saved_model_path, args.strict, args.opset)





from maths.prime_factors import prime_factors



def 							UpperCamelCase_( lowerCamelCase_					)       ->		int:
    if not isinstance(lowerCamelCase_				,					lowerCamelCase_					):
        _lowercase			:				str 						=						F'''Input value of [number={number}] must be an integer'''
        raise TypeError(lowerCamelCase_					)
    if number < 1:
        raise ValueError('Input must be a positive integer'					)
    return -1 if len(prime_factors(lowerCamelCase_					)					) % 2 else 1


if __name__ == "__main__":
 import doctest

 doctest.testmod()


