





"""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
a_					=     '''.'''

# Internal TensorFlow ops that can be safely ignored (mostly specific to a saved model)
a_					=     [
    '''Assert''',
    '''AssignVariableOp''',
    '''EmptyTensorList''',
    '''MergeV2Checkpoints''',
    '''ReadVariableOp''',
    '''ResourceGather''',
    '''RestoreV2''',
    '''SaveV2''',
    '''ShardedFilename''',
    '''StatefulPartitionedCall''',
    '''StaticRegexFullMatch''',
    '''VarHandleOp''',
]







def 						__lowercase	(  snake_case_    :    Any							,snake_case_    :    Tuple							,snake_case_    :    Optional[Any]		)  ->List[Any]:



    '''simple docstring'''







    __A       :		List[Any]							=	SavedModel()
    __A       :		Any							=	[]

    with open(os.path.join(snake_case_							,'''utils'''							,'''tf_ops'''							,'''onnx.json'''		)		) as f:
        __A       :		int							=	json.load(snake_case_		)['''opsets''']

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

    with open(snake_case_							,'''rb'''		) as f:
        saved_model.ParseFromString(f.read()		)

    __A       :		Optional[Any]							=	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
    __A       :		str							=	sorted(snake_case_		)
    __A       :		str							=	[]

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

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


if __name__ == "__main__":
       a_					=     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)"""
       )
       a_					=     parser.parse_args()

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










SCREAMING_SNAKE_CASE:     Optional[int]									= {str(digit): digit**5 for digit in range(1_0)}


def 					_a							(					lowerCAmelCase )->	int:
		return sum(DIGITS_FIFTH_POWER[digit] for digit in str(lowerCAmelCase ) )


def 					_a							(					)->	int:
		return sum(
		    number
		    for number in range(1000    ,						1000000 )
		    if number == digits_fifth_powers_sum(lowerCAmelCase ) )


if __name__ == "__main__":
						print(solution())