load("//tools/build_defs:fb_native_wrapper.bzl", "fb_native")
load("//tools/build_defs:expect.bzl", "expect")
load("//tools/build_defs:fb_xplat_genrule.bzl", "fb_xplat_genrule")
load("//tools/build_defs:type_defs.bzl", "is_list", "is_string")

# @lint-ignore BUCKRESTRICTEDSYNTAX
IS_OSS = read_config("pt", "is_oss", "0") == "1"  # True for OSS BUCK build, and False for internal BUCK build

USED_PT_BACKENDS = [
    "CPU",
    "QuantizedCPU",
    "SparseCPU",  # brings ~20 kb size regression
]

def pt_operator_library(
        name,
        ops = [],
        exported_deps = [],
        check_decl = True,
        train = False,
        model = None,
        include_all_operators = False,
        include_base_operators = True,
        **kwargs):
    (model_name, model_versions, model_assets, model_traced_backends) = validate_and_extract_model_information(
        name,
        model,
    )

    ops = [op.strip() for op in ops]

    # If ops are specified, then we are in static selective build mode, so we append
    # base ops to this list to avoid additional special case logic in subsequent code,
    # unless include_base_operators is explicitly set to False (the default is True)
    if len(ops) > 0 and include_base_operators:
        ops.extend(PT_BASE_OPS)

    labels = kwargs.pop("labels", [])
    visibility = kwargs.pop("visibility", ["PUBLIC"])

    # Sanity check the model name and versions.  While the input to both is an array, the
    # codegen script only ever outputs a single item in the array so we can just assume that
    # here. If you ever need to depends on more than one assets, just break it up into a separate
    # BUCK targets.
    if model_assets or model_versions:
        if len(model_assets) != 1:
            fail("Model assets must be of size 1")
        if len(model_versions) != 1:
            fail("Model versions must be of size 1")

    # Is this a traced operator therefore has a YAML file with ops?
    yaml_option = ""
    if model_assets and len(model_assets) > 0:
        # We know these lists are only of length 1 via earlier assert.
        model_asset = model_assets[0]
        model_version = model_versions[0]

        # Pass the YAML file from this asset to the genrule below.
        yaml_dep = "{}_v{}_yaml".format(model_asset, model_version)
        fb_native.filegroup(
            name = yaml_dep,
            srcs = [
                model_asset + ".yaml",
            ],
            # The visibility is not set to PUBLIC as this an internal detail.  If you see this error
            # in your buck build flow, you are trying to use a hand-crafted "pt_operator_library" that
            # with parameters not supported outside of codegen targets!
        )

        # Since all selective traced ops are created by automation, we can assume they
        # have a YAML file at this very location.  If it doesn't exist, it means the targets
        # was hand-crafted which is not a support workflow for traced ops.
        yaml_option = "--models_yaml_path $(location fbsource//xplat/pytorch_models/build/{}/v{}:{})/{}.yaml".format(model_name, model_version, yaml_dep, model_asset)

    fb_xplat_genrule(
        name = name,
        out = "model_operators.yaml",
        cmd = (
            "$(exe {exe}) " +
            "{optionally_root_ops} " +
            "{optionally_training_root_ops} " +
            "--rule_name {rule_name} " +
            "--output_path \"${{OUT}}\" " +
            "--model_name {model_name} " +
            "--dep_graph_yaml_path {dep_graph_yaml} " +
            "{optionally_model_yamls} " +
            "{optionally_model_versions} " +
            "{optionally_model_assets} " +
            "{optionally_model_traced_backends} " +
            "{optionally_include_all_operators}"
        ).format(
            exe = "//tools:gen_operators_yaml" if IS_OSS else "fbsource//xplat/caffe2/tools:gen_operators_yaml",
            rule_name = name,
            model_name = model_name,
            dep_graph_yaml = "none" if IS_OSS else "$(location fbsource//xplat/caffe2:pytorch_op_deps)/fb/pytorch_op_deps.yaml ",
            optionally_model_yamls = "" if (IS_OSS or yaml_option == None) else yaml_option,
            optionally_root_ops = "--root_ops " + (",".join(ops)) if len(ops) > 0 else "",
            optionally_training_root_ops = "--training_root_ops " + (",".join(ops)) if len(ops) > 0 and train else "",
            optionally_model_versions = "--model_versions " + (",".join(model_versions)) if model_versions != None else "",
            optionally_model_assets = "--model_assets " + (",".join(model_assets)) if model_assets != None else "",
            optionally_model_traced_backends = "--model_traced_backends " + (",".join(model_traced_backends)) if model_traced_backends != None else "",
            optionally_include_all_operators = "--include_all_operators " if include_all_operators else "",
        ),
        labels = labels + [
            "pt_operator_library",
            "supermodule:android/default/pytorch",
            "supermodule:ios/default/public.pytorch",
        ] + (["pt_train_operator_library"] if train else []),
        visibility = visibility,
        **kwargs
    )

def validate_and_extract_model_information(name, model):
    model_name = name
    model_versions = None
    model_assets = None
    model_traced_backends = None

    if model != None:
        model_name = model.get("name")
        expect(model_name != None, "Expected Model Name to be present")
        model_versions = model.get("versions")
        expect(is_list(model_versions), "Expected model versions to be a list of string")
        for ver in model_versions or []:
            expect(is_string(ver), "Expected version '{}' to be string".format(str(ver)))
        model_assets = model.get("assets")
        expect(
            model_assets == None or is_list(model_assets),
            "Expected model assets to be a list of string if specified",
        )
        for asset_name in model_assets or []:
            expect(is_string(asset_name), "Expected asset_name '{}' to be string".format(str(asset_name)))
        model_traced_backends = model.get("traced_backends")
        expect(
            model_traced_backends == None or is_list(model_traced_backends),
            "Expected model traced backends to be a list of string if specified",
        )

        if model_traced_backends != None:
            for backend in model_traced_backends:
                expect(is_string(backend), "Expected backend name '{}' to be string".format(str(backend)))
                expect(
                    backend in USED_PT_BACKENDS,
                    "Expected backend name ({}) to be in set: {}".format(backend, ",".join(USED_PT_BACKENDS)),
                )

    return (model_name, model_versions, model_assets, model_traced_backends)

# This file keeps a list of PyTorch operators used by any targets in
# @fbsource//xplat/...
# The purpose of the list is to avoid generating large number of unused
# operator registration code / BUCK rules at build time.
# See more detail at: https://fb.quip.com/ZVh1AgOKW8Vv

PT_OPS_PRIM = [
    "aten::str",
    "aten::list",
    "aten::__range_length",
    "aten::__derive_index",
    "prim::TupleUnpack",
    "prim::unchecked_cast",
    "aten::IntImplicit",
    "aten::FloatImplicit",
    "aten::ScalarImplicit",
    "aten::Bool.Tensor",
    "aten::Bool.int",
    "aten::Bool.float",
    "aten::Int.Tensor",
    "aten::Int.Scalar",
    "aten::Int.int",
    "aten::Int.bool",
    "aten::Int.str",
    "aten::Float.Tensor",
    "aten::Float.Scalar",
    "aten::Float.int",
    "aten::Float.bool",
    "aten::Float.str",
    "aten::format",
    "prim::NumToTensor.Scalar",
    "prim::RaiseException",
    "aten::Size",
    "aten::size",
    "prim::EnumName",
    "prim::EnumValue.int",
    "prim::EnumValue.float",
    "prim::EnumValue.str",
    "prim::TupleIndex",
    "aten::ne.int_list",
    "prim::unchecked_unwrap_optional",
    "prim::device",
    "prim::dtype",
    "aten::__not__",
    "aten::__is__",
    "aten::__isnot__",
    "aten::element_size",
    "aten::numel",
    "aten::dim",
    "aten::get_device",
    "aten::storage_offset",
    "aten::is_contiguous",
    "aten::select.t",
    "aten::__getitem__.t",
    "aten::append.t",
    "aten::reverse.t",
    "aten::extend.t",
    "aten::copy.t",
    "aten::_set_item.t",
    "aten::clear.t",
    "aten::Delete.t",
    "aten::insert.t",
    "aten::pop.t",
    "aten::add.t",
    "aten::add_.t",
    "aten::slice.t",
    "aten::list.t",
    "aten::mul.left_t",
    "aten::mul.right_",
    "aten::mul_.t",
    "aten::len.t",
    "aten::eq.int_list",
    "prim::Uninitialized",
    "prim::Print",
    "aten::eq.enum",
    "aten::ne.enum",
    "aten::dequantize.tensor",
    "aten::dequantize.any",
    "aten::add.str",
    "aten::eq.int",
    "aten::eq.float",
    "aten::eq.int_float",
    "aten::eq.float_int",
    "aten::eq",
    "aten::eq.str",
    "aten::ne.int",
    "aten::ne.float",
    "aten::ne.int_float",
    "aten::ne.float_int",
    "aten::ne",
    "aten::ne.str",
    "aten::lt.int",
    "aten::lt.float",
    "aten::lt.int_float",
    "aten::lt.float_int",
    "aten::lt",
    "aten::lt.str",
    "aten::gt.int",
    "aten::gt.float",
    "aten::gt.int_float",
    "aten::gt.float_int",
    "aten::gt",
    "aten::gt.str",
    "aten::le.int",
    "aten::le.float",
    "aten::le.int_float",
    "aten::le.float_int",
    "aten::le",
    "aten::le.str",
    "aten::ge.int",
    "aten::ge.float",
    "aten::ge.int_float",
    "aten::ge.float_int",
    "aten::ge",
    "aten::ge.str",
    "aten::add.int",
    "aten::add.float",
    "aten::add.int_float",
    "aten::add.float_int",
    "aten::add",
    "aten::sub.int",
    "aten::sub.float",
    "aten::sub.int_float",
    "aten::sub.float_int",
    "aten::sub",
    "aten::mul.int",
    "aten::mul.float",
    "aten::mul.int_float",
    "aten::mul.float_int",
    "aten::mul",
    "aten::__and__.bool",
    "aten::__or__.bool",
    "aten::__xor__.bool",
    "aten::floor.int",
    "aten::floor.float",
    "aten::floor.Scalar",
    "aten::ceil.int",
    "aten::ceil.float",
    "aten::ceil.Scalar",
    "aten::neg.int",
    "aten::neg.float",
    "aten::neg.Scalar",
    "aten::exp.int",
    "aten::exp.float",
    "aten::exp.Scalar",
    "aten::remainder.int",
    "aten::remainder.float",
    "aten::remainder.int_float",
    "aten::remainder.float_int",
    "aten::remainder",
    "aten::div.int",
    "aten::div.float",
    "aten::div",
    "aten::floordiv.int",
    "aten::floordiv.float",
    "aten::floordiv.int_float",
    "aten::floordiv.float_int",
    "aten::floordiv",
    "aten::pow.int",
    "aten::pow.float",
    "aten::pow.int_float",
    "aten::pow.float_int",
    "aten::pow.Scalar_Scalar",
    "aten::pow.int_to_int",
    "prim::min.int",
    "prim::min.float",
    "prim::min.int_float",
    "prim::min.float_int",
    "prim::min",
    "prim::max.int",
    "prim::max.float",
    "prim::max.int_float",
    "prim::max.float_int",
    "prim::max",
    "prim::type",
    "aten::len.Tensor",
    "aten::ord",
    "aten::lower",
    "aten::__contains__.str_list",
    "aten::len.str",
    "aten::__getitem__.str",
    "aten::copy_.Tensor",
    "aten::copy_.int",
    "aten::copy_.float",
    "aten::backward",
    "aten::index.Tensor_hacked_twin",
    "aten::_unsafe_index.Tensor_hacked_twin",
    "aten::_index_put_impl_.hacked_twin",
    "aten::index_put_.hacked_twin",
    "aten::index_put.hacked_twin",
    "aten::_unsafe_index_put.hacked_twin",
    "aten::to.prim_Device",
    "aten::to.prim_dtype",
    "prim::is_cuda",
    "prim::data",
    "prim::min.int_list",
    "prim::max.int_list",
    "prim::min.self_int",
    "prim::max.self_int",
    "prim::min.float_list",
    "prim::max.float_list",
    "prim::min.self_float",
    "prim::max.self_float",
    "prim::min.bool_list",
    "prim::max.bool_list",
    "prim::min.self_bool",
    "prim::max.self_bool",
    "aten::len.Dict_str",
    "aten::keys.str",
    "aten::values.str",
    "aten::__getitem__.Dict_str",
    "aten::get.str",
    "aten::get.default_str",
    "aten::setdefault.str",
    "aten::Delete.Dict_str",
    "aten::pop.Dict_str",
    "aten::pop.Dict_default_str",
    "aten::popitem.str",
    "aten::clear.str",
    "aten::update.str",
    "aten::items.str",
    "aten::copy.Dict_str",
    "aten::__contains__.str",
    "aten::_set_item.str",
    "aten::dict.str",
    "aten::len.Dict_int",
    "aten::keys.int",
    "aten::values.int",
    "aten::__getitem__.Dict_int",
    "aten::get.int",
    "aten::get.default_int",
    "aten::setdefault.int",
    "aten::Delete.Dict_int",
    "aten::pop.Dict_int",
    "aten::pop.Dict_default_int",
    "aten::popitem.int",
    "aten::clear.int",
    "aten::update.int",
    "aten::items.int",
    "aten::copy.Dict_int",
    "aten::__contains__.int",
    "aten::_set_item.int",
    "aten::dict.int",
    "aten::len.Dict_bool",
    "aten::keys.bool",
    "aten::values.bool",
    "aten::__getitem__.Dict_bool",
    "aten::get.bool",
    "aten::get.default_bool",
    "aten::setdefault.bool",
    "aten::Delete.Dict_bool",
    "aten::pop.Dict_bool",
    "aten::pop.Dict_default_bool",
    "aten::popitem.bool",
    "aten::clear.bool",
    "aten::update.bool",
    "aten::items.bool",
    "aten::copy.Dict_bool",
    "aten::__contains__.bool",
    "aten::_set_item.bool",
    "aten::dict.bool",
    "aten::len.Dict_float",
    "aten::keys.float",
    "aten::values.float",
    "aten::__getitem__.Dict_float",
    "aten::get.float",
    "aten::get.default_float",
    "aten::setdefault.float",
    "aten::Delete.Dict_float",
    "aten::pop.Dict_float",
    "aten::pop.Dict_default_float",
    "aten::popitem.float",
    "aten::clear.float",
    "aten::update.float",
    "aten::items.float",
    "aten::copy.Dict_float",
    "aten::__contains__.float",
    "aten::_set_item.float",
    "aten::dict.float",
    "aten::len.Dict_Tensor",
    "aten::keys.Tensor",
    "aten::values.Tensor",
    "aten::__getitem__.Dict_Tensor",
    "aten::get.Tensor",
    "aten::get.default_Tensor",
    "aten::setdefault.Tensor",
    "aten::Delete.Dict_Tensor",
    "aten::pop.Dict_Tensor",
    "aten::pop.Dict_default_Tensor",
    "aten::popitem.Tensor",
    "aten::clear.Tensor",
    "aten::update.Tensor",
    "aten::items.Tensor",
    "aten::copy.Dict_Tensor",
    "aten::__contains__.Tensor",
    "aten::_set_item.Tensor",
    "aten::dict.Tensor",
    "aten::__round_to_zero_floordiv.int",
    "aten::mathremainder.int",
    "aten::mathremainder.float",
    "aten::mathremainder.int_float",
    "aten::mathremainder.float_int",
    "aten::mathremainder",
    "aten::__and__.int",
    "aten::__or__.int",
    "aten::__xor__.int",
    "aten::__lshift__.int",
    "aten::__rshift__.int",
    "aten::round.int",
    "aten::round.float",
    "aten::round.Scalar",
    "aten::log.int",
    "aten::log.float",
    "aten::log.Scalar",
    "aten::log.int_int",
    "aten::log.float_float",
    "aten::log.int_float",
    "aten::log.float_int",
    "aten::log.Scalar_Scalar",
    "aten::log1p.int",
    "aten::log1p.float",
    "aten::log1p.Scalar",
    "aten::log10.int",
    "aten::log10.float",
    "aten::log10.Scalar",
    "aten::sqrt.int",
    "aten::sqrt.float",
    "aten::sqrt.Scalar",
    "aten::acos.int",
    "aten::acos.float",
    "aten::acos.Scalar",
    "aten::asin.int",
    "aten::asin.float",
    "aten::asin.Scalar",
    "aten::atan.int",
    "aten::atan.float",
    "aten::atan.Scalar",
    "aten::atan2.int",
    "aten::atan2.float",
    "aten::atan2.int_float",
    "aten::atan2.float_int",
    "aten::atan2.Scalar_Scalar",
    "aten::cos.int",
    "aten::cos.float",
    "aten::cos.Scalar",
    "aten::sin.int",
    "aten::sin.float",
    "aten::sin.Scalar",
    "aten::tan.int",
    "aten::tan.float",
    "aten::tan.Scalar",
    "aten::asinh.int",
    "aten::asinh.float",
    "aten::asinh.Scalar",
    "aten::atanh.int",
    "aten::atanh.float",
    "aten::atanh.Scalar",
    "aten::acosh.int",
    "aten::acosh.float",
    "aten::acosh.Scalar",
    "aten::sinh.int",
    "aten::sinh.float",
    "aten::sinh.Scalar",
    "aten::cosh.int",
    "aten::cosh.float",
    "aten::cosh.Scalar",
    "aten::tanh.int",
    "aten::tanh.float",
    "aten::tanh.Scalar",
    "aten::degrees.int",
    "aten::degrees.float",
    "aten::degrees.Scalar",
    "aten::radians.int",
    "aten::radians.float",
    "aten::radians.Scalar",
    "aten::fmod.int",
    "aten::fmod.float",
    "aten::fmod.int_float",
    "aten::fmod.float_int",
    "aten::fmod",
    "aten::factorial.int",
    "aten::isnan.float",
    "aten::isfinite.float",
    "aten::isinf.float",
    "aten::gamma.int",
    "aten::gamma.float",
    "aten::gamma.Scalar",
    "aten::erf.int",
    "aten::erf.float",
    "aten::erf.Scalar",
    "aten::erfc.int",
    "aten::erfc.float",
    "aten::erfc.Scalar",
    "aten::expm1.int",
    "aten::expm1.float",
    "aten::expm1.Scalar",
    "aten::fabs.int",
    "aten::fabs.float",
    "aten::fabs.Scalar",
    "aten::lgamma.int",
    "aten::lgamma.float",
    "aten::lgamma.Scalar",
    "prim::abs.int",
    "prim::abs.float",
    "prim::abs.Scalar",
    "aten::gcd.int",
    "aten::copysign.int",
    "aten::copysign.float",
    "aten::copysign.int_float",
    "aten::copysign.float_int",
    "aten::copysign",
    "aten::split",
    "aten::tensor.float",
    "aten::as_tensor.float",
    "aten::tensor.int",
    "aten::as_tensor.int",
    "aten::tensor.bool",
    "aten::as_tensor.bool",
    "aten::_infer_size",
    "aten::_no_grad_embedding_renorm_",
    "aten::tensor",
    "aten::as_tensor",
    "aten::as_tensor.list",
    "aten::_pack_sequence",
    "aten::_get_tracing_state",
    "aten::is_scripting",
    "aten::_no_grad_uniform_",
    "aten::_no_grad_normal_",
    "aten::_no_grad_fill_",
    "aten::_no_grad_zero_",
]

PT_BASE_OPS = [
    "aten::_coalesced_",
    "aten::_copy_from",
    "aten::_empty_affine_quantized",
    "aten::_empty_per_channel_affine_quantized",
    "aten::_indices",
    "aten::_nnz",
    "aten::_values",
    "aten::add",
    "aten::add_",
    "aten::arange",
    "aten::as_strided",
    "aten::as_strided_",
    "aten::cat",
    "aten::clone",
    "aten::coalesce",
    "aten::contiguous",
    "aten::copy_",
    "aten::copy_sparse_to_sparse_",
    "aten::dense_dim",
    "aten::dequantize",
    "aten::div",
    "aten::div_",
    "aten::empty",
    "aten::empty_like",
    "aten::empty_strided",
    "aten::eq",
    "aten::equal",
    "aten::expand",
    "aten::fill_",
    "aten::is_coalesced",
    "aten::is_complex",
    "aten::is_floating_point",
    "aten::is_leaf",
    "aten::is_nonzero",
    "aten::item",
    "aten::max",
    "aten::min",
    "aten::mul",
    "aten::mul_",
    "aten::narrow",
    "aten::ne",
    "aten::permute",
    "aten::q_per_channel_axis",
    "aten::q_per_channel_scales",
    "aten::q_per_channel_zero_points",
    "aten::q_scale",
    "aten::q_zero_point",
    "aten::qscheme",
    "aten::quantize_per_tensor",
    "aten::reshape",
    "aten::_reshape_alias",
    "aten::resize_",
    "aten::resize_as_",
    "aten::scalar_tensor",
    "aten::select",
    "aten::set_",
    "aten::size",
    "aten::slice",
    "aten::sparse_dim",
    "aten::sparse_resize_and_clear_",
    "aten::squeeze",
    "aten::squeeze_",
    "aten::stride",
    "aten::sub",
    "aten::sub_",
    "aten::sum",
    "aten::t",
    "aten::to",
    "aten::_to_copy",
    "aten::unsqueeze",
    "aten::view",
    "aten::zero_",
    "aten::zeros",
    "aten::zeros_like",
]