/* Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
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. */
#pragma once

#if defined(_MSC_VER)
#include <BaseTsd.h>
typedef SSIZE_T ssize_t;
#endif

#include <Python.h>

#include "paddle/fluid/eager/grad_node_info.h"
#include "paddle/fluid/eager/hooks.h"
#include "paddle/fluid/framework/dense_tensor_array.h"
#include "paddle/fluid/framework/lod_tensor.h"
#include "paddle/fluid/framework/tensor.h"
#include "paddle/fluid/jit/function.h"
#include "paddle/phi/api/lib/kernel_dispatch.h"
#include "paddle/phi/common/backend.h"
#include "paddle/phi/common/data_type.h"
#include "paddle/phi/common/int_array.h"
#include "paddle/phi/common/place.h"
#include "paddle/phi/common/scalar.h"
#include "paddle/phi/core/dense_tensor.h"
#include "paddle/phi/core/distributed/auto_parallel/dist_attr.h"
#include "paddle/phi/core/distributed/auto_parallel/dist_tensor.h"
#include "paddle/phi/core/distributed/auto_parallel/process_mesh.h"
#include "paddle/phi/core/enforce.h"
#include "paddle/phi/core/selected_rows.h"
#include "paddle/phi/core/vocab/string_array.h"
#include "paddle/pir/include/core/value.h"
#include "paddle/utils/pybind.h"
#include "pybind11/pybind11.h"
#include "pybind11/stl.h"

namespace paddle {
class CustomOpKernelContext;
namespace framework {
class Scope;
}
namespace pybind {

namespace py = ::pybind11;

template <typename T>
static T PyObjectCast(PyObject* obj) {
  try {
    return py::cast<T>(py::handle(obj));
  } catch (py::cast_error&) {
    PADDLE_THROW(common::errors::InvalidArgument(
        "Python object is not type of %s, the real type is %s",
        typeid(T).name(),
        obj->ob_type->tp_name));
  }
}

int TensorDtype2NumpyDtype(DataType dtype);

bool PyObject_CheckStr(PyObject* obj);
bool PyObject_CheckIRValue(PyObject* obj);
bool PyObject_CheckIRVectorOfValue(PyObject* obj);
bool PyObject_CheckIRVectorOfValueOrLong(PyObject* obj);
bool CastPyArg2AttrBoolean(PyObject* obj, ssize_t arg_pos);
int CastPyArg2AttrInt(PyObject* obj, ssize_t arg_pos);
int64_t CastPyArg2AttrLong(PyObject* obj, ssize_t arg_pos);
size_t CastPyArg2AttrSize_t(PyObject* obj, ssize_t arg_pos);
float CastPyArg2AttrFloat(PyObject* obj, ssize_t arg_pos);
double CastPyArg2AttrDouble(PyObject* obj, ssize_t arg_pos);
std::string CastPyArg2AttrString(PyObject* obj, ssize_t arg_pos);
std::shared_ptr<imperative::VarBase> CastPyArg2VarBase(PyObject* obj,
                                                       ssize_t arg_pos);
std::vector<Tensor> CastPyArg2VectorOfTensor(
    PyObject* obj,
    ssize_t arg_pos,
    const phi::distributed::ProcessMesh* mesh = nullptr);
Place CastPyArg2Place(PyObject* obj, ssize_t arg_pos);
DenseTensor CastPyArg2FrameworkTensor(PyObject* obj, ssize_t arg_pos);
std::vector<DenseTensor> CastPyArg2VectorOfTensorBase(PyObject* obj,
                                                      ssize_t arg_pos);
std::vector<int> CastPyArg2VectorOfInt(PyObject* obj, size_t arg_pos);
std::vector<int64_t> CastPyArg2VectorOfInt64(PyObject* obj, size_t arg_pos);
std::vector<size_t> CastPyArg2VectorOfSize_t(PyObject* obj, size_t arg_pos);
std::vector<float> CastPyArg2VectorOfFloat(PyObject* obj, size_t arg_pos);
pir::Value CastPyArg2Value(PyObject* obj,
                           const std::string& op_type,
                           size_t arg_pos,
                           bool dispensable = false);
paddle::optional<pir::Value> CastPyArg2OptionalValue(PyObject* obj,
                                                     const std::string& op_type,
                                                     size_t arg_pos,
                                                     bool dispensable = false);
std::vector<pir::Value> CastPyArg2VectorOfValue(PyObject* obj,
                                                const std::string& op_type,
                                                size_t arg_pos,
                                                bool dispensable = false);
std::vector<pir::Value> CastPyArg2VectorOfValueOrLong(
    PyObject* obj,
    const std::string& op_type,
    size_t arg_pos,
    bool dispensable = false);
paddle::optional<std::vector<pir::Value>> CastPyArg2OptionalVectorOfValue(
    PyObject* obj,
    const std::string& op_type,
    size_t arg_pos,
    bool dispensable = false);
std::vector<std::vector<size_t>> CastPyArg2VectorOfVectorOfSize_t(
    PyObject* obj, size_t arg_pos);
framework::proto::VarType::Type CastPyArg2ProtoType(PyObject* obj,
                                                    ssize_t arg_pos);
phi::Vocab CastPyArg2Vocab(PyObject* obj, ssize_t arg_pos);
std::vector<std::string> CastPyArg2VectorOfString(PyObject* obj,
                                                  ssize_t arg_pos);
std::shared_ptr<jit::Function> CastPyArg2JitFunction(PyObject* obj,
                                                     ssize_t arg_pos);
void SetPythonStack();
std::string GetPythonStack();

PyObject* ToPyObject(int value);
PyObject* ToPyObject(uint32_t value);
PyObject* ToPyObject(bool value);
PyObject* ToPyObject(int64_t value);
PyObject* ToPyObject(size_t value);
PyObject* ToPyObject(float value);
PyObject* ToPyObject(double value);
PyObject* ToPyObject(const char* value);
PyObject* ToPyObject(const std::string& value);
PyObject* ToPyObject(const Tensor& value,
                     PyObject* args,
                     const std::map<ssize_t, ssize_t>& inplace_var_idx_map);
PyObject* ToPyObject(PyObject* args, ssize_t arg_idx);
PyObject* ToPyObject(
    const Tensor& value,
    PyObject* args,
    PyObject* kwargs,
    const std::map<ssize_t, ssize_t>& inplace_var_idx_map,
    const std::map<ssize_t, std::vector<std::string>>& inplace_var_name_map);
PyObject* ToPyObject(PyObject* args,
                     PyObject* kwargs,
                     ssize_t arg_idx,
                     std::vector<std::string> arg_names);
PyObject* ToPyObject(const std::vector<bool>& value);
PyObject* ToPyObject(const std::vector<int>& value);
PyObject* ToPyObject(const std::vector<int64_t>& value);
PyObject* ToPyObject(const std::vector<size_t>& value);
PyObject* ToPyObject(const std::vector<float>& value);
PyObject* ToPyObject(const std::vector<double>& value);
PyObject* ToPyObject(const std::vector<std::vector<size_t>>& value);
PyObject* ToPyObject(const std::vector<Tensor>& value,
                     bool return_py_none_if_not_initialize = false);
PyObject* ToPyObject(const std::vector<std::vector<Tensor>>& value,
                     bool return_py_none_if_not_initialize = false);
PyObject* ToPyObject(const Place& value);
PyObject* ToPyObject(const phi::DenseTensor* value);
PyObject* ToPyObject(const phi::distributed::DistTensor* value);
PyObject* ToPyObject(const phi::distributed::TensorDistAttr* value);
PyObject* ToPyObject(const phi::distributed::ProcessMesh* value);
PyObject* ToPyObject(const phi::distributed::Placements& value);
PyObject* ToPyObject(const phi::SelectedRows* value);
PyObject* ToPyObject(const paddle::framework::proto::VarType::Type& dtype);
PyObject* ToPyObject(const paddle::framework::proto::VarType& type);
PyObject* ToPyObject(const std::vector<DataType>& dtypes);
PyObject* ToPyObject(const void* value);
PyObject* ToPyObject(const std::unordered_map<int, int>& value);
PyObject* ToPyObject(
    const std::unordered_map<std::string, std::vector<std::string>>& value);
PyObject* ToPyObject(const phi::Vocab& value);

PyObject* ToPyObject(std::shared_ptr<egr::GradNodeBase> grad_node);
PyObject* ToPyObject(const pir::Value& value);
PyObject* ToPyObject(pir::Operation* op);
PyObject* ToPyObject(const std::vector<pir::Value>& value);

class PyTensorHook : public egr::TensorHook {
 public:
  explicit PyTensorHook(PyObject* func) : py_func_(func) {
    Py_INCREF(py_func_);
  }

  ~PyTensorHook() {
    py::gil_scoped_acquire gil;
    Py_DECREF(py_func_);
  }

  Tensor operator()(const Tensor& var) override;

 private:
  PyObject* py_func_;
};

class PyVoidHook : public egr::VoidHook {
 public:
  explicit PyVoidHook(PyObject* func) : py_func_(func) { Py_INCREF(py_func_); }

  ~PyVoidHook() {
    py::gil_scoped_acquire gil;
    Py_DECREF(py_func_);
  }

  void operator()() override;

 private:
  PyObject* py_func_;
};

class PyObjectHolder : public egr::PyObjectHolderBase {
 public:
  PyObjectHolder() { ptr_ = nullptr; }
  explicit PyObjectHolder(PyObject* ptr);
  ~PyObjectHolder() override;
  void* get() override;
  void reset(void* ptr) override;
  void inc_ref() override;
  void dec_ref() override;

 private:
  PyObject* ptr_{nullptr};
};

class PackHook : public egr::PackHookBase {
 public:
  explicit PackHook(PyObject* hook);

  ~PackHook();

  std::shared_ptr<egr::PyObjectHolderBase> operator()(
      const Tensor& tensor) override;

  void* operator()(void* py_tensor) override;

 private:
  PyObject* hook_;
};

class UnPackHook : public egr::UnPackHookBase {
 public:
  explicit UnPackHook(PyObject* hook);

  ~UnPackHook();

  Tensor operator()(
      std::shared_ptr<egr::PyObjectHolderBase> packed_value) override;

  void* operator()(void* packed_value, void* other) override;

 private:
  PyObject* hook_;
};

#pragma GCC visibility push(hidden)
class NodePostHook : public egr::NodePostHookBase {
 public:
  explicit NodePostHook(py::object hook) : hook_(hook) {}

  ~NodePostHook() {}

  paddle::small_vector<std::vector<Tensor>, egr::kSlotSmallVectorSize>
  operator()(
      const paddle::small_vector<std::vector<Tensor>,
                                 egr::kSlotSmallVectorSize>& grad_outputs,
      const paddle::small_vector<std::vector<Tensor>,
                                 egr::kSlotSmallVectorSize>& grad_inputs)
      override;

 private:
  py::object hook_;
};
#pragma GCC visibility pop

template <typename Tuple, size_t N>
struct TupleTensorResult {
  static void Run(const Tuple& out, PyObject* result) {
    TupleTensorResult<Tuple, N - 1>::Run(out, result);
    PyTuple_SET_ITEM(result, N - 1, ToPyObject(std::get<N - 1>(out)));
  }

  static void Run(const Tuple& out,
                  PyObject* result,
                  PyObject* args,
                  const std::map<ssize_t, ssize_t>& inplace_var_idx_map) {
    TupleTensorResult<Tuple, N - 1>::Run(
        out, result, args, inplace_var_idx_map);
    if (!inplace_var_idx_map.empty() && inplace_var_idx_map.count(N - 1)) {
      PyTuple_SET_ITEM(
          result, N - 1, ToPyObject(args, inplace_var_idx_map.at(N - 1)));
    } else {
      PyTuple_SET_ITEM(result, N - 1, ToPyObject(std::get<N - 1>(out)));
    }
  }

  static void Run(
      const Tuple& out,
      PyObject* result,
      PyObject* args,
      PyObject* kwargs,
      const std::map<ssize_t, ssize_t>& inplace_var_idx_map,
      const std::map<ssize_t, std::vector<std::string>>& inplace_var_name_map) {
    TupleTensorResult<Tuple, N - 1>::Run(
        out, result, args, kwargs, inplace_var_idx_map, inplace_var_name_map);
    if (!inplace_var_idx_map.empty() && inplace_var_idx_map.count(N - 1)) {
      PyTuple_SET_ITEM(result,
                       N - 1,
                       ToPyObject(args,
                                  kwargs,
                                  inplace_var_idx_map.at(N - 1),
                                  inplace_var_name_map.at(N - 1)));
    } else {
      PyTuple_SET_ITEM(result, N - 1, ToPyObject(std::get<N - 1>(out)));
    }
  }
};

template <typename Tuple>
struct TupleTensorResult<Tuple, 1> {
  static void Run(const Tuple& out, PyObject* result) {
    PyTuple_SET_ITEM(result, 0, ToPyObject(std::get<0>(out)));
  }

  static void Run(const Tuple& out,
                  PyObject* result,
                  PyObject* args,
                  const std::map<ssize_t, ssize_t>& inplace_var_idx_map) {
    if (!inplace_var_idx_map.empty() && inplace_var_idx_map.count(0)) {
      PyTuple_SET_ITEM(result, 0, ToPyObject(args, inplace_var_idx_map.at(0)));
    } else {
      PyTuple_SET_ITEM(result, 0, ToPyObject(std::get<0>(out)));
    }
  }

  static void Run(
      const Tuple& out,
      PyObject* result,
      PyObject* args,
      PyObject* kwargs,
      const std::map<ssize_t, ssize_t>& inplace_var_idx_map,
      const std::map<ssize_t, std::vector<std::string>>& inplace_var_name_map) {
    if (!inplace_var_idx_map.empty() && inplace_var_idx_map.count(0)) {
      PyTuple_SET_ITEM(result,
                       0,
                       ToPyObject(args,
                                  kwargs,
                                  inplace_var_idx_map.at(0),
                                  inplace_var_name_map.at(0)));
    } else {
      PyTuple_SET_ITEM(result, 0, ToPyObject(std::get<0>(out)));
    }
  }
};

template <typename... Args>
PyObject* ToPyObject(const std::tuple<Args...>& out) {
  auto len = sizeof...(Args);
  PyObject* result = PyTuple_New(len);

  TupleTensorResult<decltype(out), sizeof...(Args)>::Run(out, result);

  return result;
}

template <typename... Args>
PyObject* ToPyObject(const std::tuple<Args...>& out,
                     PyObject* args,
                     const std::map<ssize_t, ssize_t>& inplace_var_idx_map) {
  // For inplace op, directly return the input PyObject of the inplace tensor.
  // [Parameter]
  // out: Outputs tuple after executing op.
  // args: Input PyObject.
  // inplace_var_idx_map: Index of Tensors in inplace_map, e.g. {{value_idx,
  // arg_idx}}.
  // - value_idx: Index of inplace tensor in outputs tuple. Used to find the
  // output inplace tensor.
  // - arg_idx: Index of inplace PyObject in input args. Used to find the input
  // inplace PyObject.
  auto len = sizeof...(Args);
  PyObject* result = PyTuple_New(len);

  TupleTensorResult<decltype(out), sizeof...(Args)>::Run(
      out, result, args, inplace_var_idx_map);

  return result;
}

template <typename... Args>
PyObject* ToPyObject(
    const std::tuple<Args...>& out,
    PyObject* args,
    PyObject* kwargs,
    const std::map<ssize_t, ssize_t>& inplace_var_idx_map,
    const std::map<ssize_t, std::vector<std::string>>& inplace_var_name_map) {
  // For inplace op, directly return the input PyObject of the inplace tensor.
  // [Parameter]
  // out: Outputs tuple after executing op.
  // args: Input PyObject.
  // kwargs: Input PyObject.
  // inplace_var_idx_map: Index of Tensors in inplace_map, e.g. {{value_idx,
  // arg_idx}}.
  // - value_idx: Index of inplace tensor in outputs tuple. Used to find the
  // output inplace tensor.
  // - arg_idx: Index of inplace PyObject in input args. Used to find the input
  // inplace PyObject.
  // inplace_var_name_map: Name of Tensors in inplace_map
  auto len = sizeof...(Args);
  PyObject* result = PyTuple_New(len);

  TupleTensorResult<decltype(out), sizeof...(Args)>::Run(
      out, result, args, kwargs, inplace_var_idx_map, inplace_var_name_map);

  return result;
}

paddle::experimental::Scalar CastPyArg2Scalar(PyObject* obj,
                                              const std::string& op_type,
                                              ssize_t arg_pos);
paddle::experimental::Scalar CastPyArg2Scalar(
    PyObject* obj,
    const std::string& op_type,
    ssize_t arg_pos,
    paddle::experimental::Scalar default_value);
paddle::experimental::Scalar CastNumpy2Scalar(PyObject* obj,
                                              const std::string& op_type,
                                              ssize_t arg_pos);

std::vector<phi::Scalar> CastPyArg2ScalarArray(PyObject* obj,
                                               const std::string& op_type,
                                               ssize_t arg_pos);
std::vector<phi::Scalar> CastPyArg2ScalarArray(PyObject* obj,
                                               const std::string& op_type,
                                               ssize_t arg_pos,
                                               std::vector<phi::Scalar>);

paddle::experimental::IntArray CastPyArg2IntArray(PyObject* obj,
                                                  const std::string& op_type,
                                                  ssize_t arg_pos);
paddle::experimental::IntArray CastPyArg2IntArray(
    PyObject* obj,
    const std::string& op_type,
    ssize_t arg_pos,
    paddle::experimental::IntArray default_value);
Place CastPyArg2Place(PyObject* obj,
                      const std::string& op_type,
                      ssize_t arg_pos);
Place CastPyArg2Place(PyObject* obj,
                      const std::string& op_type,
                      ssize_t arg_pos,
                      Place default_place);

DataType CastPyArg2DataType(PyObject* obj,
                            const std::string& op_type,
                            ssize_t arg_pos);
DataType CastPyArg2DataType(PyObject* obj,
                            const std::string& op_type,
                            ssize_t arg_pos,
                            DataType default_value);

DataType CastPyArg2DataTypeDirectly(PyObject* obj,
                                    const std::string& op_type,
                                    ssize_t arg_pos);
DataType CastPyArg2DataTypeDirectly(PyObject* obj,
                                    const std::string& op_type,
                                    ssize_t arg_pos,
                                    DataType default_value);

phi::distributed::TensorDistAttr CastPyArg2DistAttr(PyObject* obj,
                                                    ssize_t arg_pos);

phi::distributed::ProcessMesh CastPyArg2ProcessMesh(PyObject* obj,
                                                    ssize_t arg_pos);

std::vector<phi::distributed::ProcessMesh> CastPyArg2VectorOfProcessMesh(
    PyObject* obj, ssize_t arg_pos);

phi::distributed::Placements CastPyArg2VectorOfPlacement(PyObject* obj,
                                                         ssize_t arg_pos);

paddle::optional<Tensor> GetOptionalTensorFromArgs(
    const std::string& op_type,
    const std::string& arg_name,
    PyObject* args,
    ssize_t arg_idx,
    bool dispensable = false,
    const phi::distributed::ProcessMesh* mesh = nullptr);

paddle::optional<Tensor> GetOptionalTensorFromArgsOrKWArgs(
    const std::string& op_type,
    const std::string& arg_name,
    PyObject* args,
    ssize_t arg_idx,
    PyObject* kwargs,
    const std::vector<std::string>& keywords,
    const int nargs,
    int* remaining_kwargs,
    bool dispensable = false,
    const phi::distributed::ProcessMesh* mesh = nullptr);

Tensor& GetTensorFromArgs(const std::string& op_type,
                          const std::string& arg_name,
                          PyObject* args,
                          ssize_t arg_idx,
                          bool dispensable = false);

paddle::optional<std::vector<Tensor>> GetOptionalTensorListFromArgs(
    const std::string& op_type,
    const std::string& arg_name,
    PyObject* args,
    ssize_t arg_idx,
    bool dispensable = false,
    const phi::distributed::ProcessMesh* mesh = nullptr);

std::vector<Tensor> GetTensorListFromArgs(
    const std::string& op_type,
    const std::string& arg_name,
    PyObject* args,
    ssize_t arg_idx,
    bool dispensable = false,
    const phi::distributed::ProcessMesh* mesh = nullptr);

std::vector<Tensor> GetTensorListFromArgsOrKWArgs(
    const std::string& op_type,
    const std::string& arg_name,
    PyObject* args,
    ssize_t arg_idx,
    PyObject* kwargs,
    const std::vector<std::string>& keywords,
    const int nargs,
    int* remaining_kwargs,
    bool dispensable,
    const phi::distributed::ProcessMesh* mesh = nullptr);

Tensor* GetTensorPtrFromArgs(const std::string& op_type,
                             const std::string& arg_name,
                             PyObject* args,
                             ssize_t arg_idx,
                             bool dispensable = false);

std::vector<Tensor*> GetTensorPtrListFromArgs(
    const std::string& op_type,
    const std::string& arg_name,
    PyObject* args,
    ssize_t arg_idx,
    bool dispensable = false,
    const phi::distributed::ProcessMesh* mesh = nullptr);

std::vector<Tensor*> GetTensorPtrListFromPyObject(PyObject* obj);

std::vector<Tensor> GetTensorListFromPyObject(PyObject* obj,
                                              bool allow_none = false);
Tensor& UnSafeGetTensorFromPyObject(PyObject* obj);

PyObject* GetEmptyTensorsWithVarDesc(PyObject* self, PyObject* args);

PyObject* GetEmptyTensorsWithValue(PyObject* self, PyObject* args);

// end of Slice related methods

std::vector<paddle::framework::Scope*> GetScopePtrListFromArgs(
    const std::string& op_type,
    const std::string& arg_name,
    PyObject* args,
    ssize_t arg_idx,
    bool dispensable);

paddle::framework::AttributeMap* GetProgramAttributesMapPtrFromPyArgs(
    const std::string& op_type, PyObject* args, ssize_t arg_idx);

class eager_gil_scoped_release {
 public:
  eager_gil_scoped_release() { tstate = PyEval_SaveThread(); }
  ~eager_gil_scoped_release() {
    if (!tstate) return;
    PyEval_RestoreThread(tstate);
  }

 private:
  PyThreadState* tstate{nullptr};
};

class TensorListBufferAllocator {
 private:
  struct TensorListBuffer {
    bool is_available;
    std::vector<Tensor> buffer;
    TensorListBuffer() = default;
    explicit TensorListBuffer(ssize_t len) : is_available(true), buffer(len) {}
  };

  using MapType =
      std::unordered_multimap<ssize_t, std::unique_ptr<TensorListBuffer>>;
  using MapIterType = MapType::iterator;

  ssize_t key_;
  TensorListBuffer* buffer_ptr_ = nullptr;
  static MapType s_tensor_vector_map_;

 public:
  explicit TensorListBufferAllocator(ssize_t len);
  TensorListBufferAllocator(const TensorListBufferAllocator&) = delete;
  TensorListBufferAllocator& operator=(const TensorListBufferAllocator&) =
      delete;
  ~TensorListBufferAllocator();
  std::vector<Tensor>& GetAllocatedBuffer() const {
    return buffer_ptr_->buffer;
  }
};

std::pair<PyObject*, ssize_t> GetPyArgumentInfo(const std::string& op_type,
                                                const std::string& arg_name,
                                                PyObject* args,
                                                ssize_t arg_idx,
                                                bool dispensable);

std::vector<Tensor>& GetTensorListFromArgsWithBuffer(
    const std::string& op_type,
    const std::string& arg_name,
    ssize_t arg_idx,
    const phi::distributed::ProcessMesh* mesh,
    PyObject* list,
    ssize_t list_len,
    const TensorListBufferAllocator& allocator);

/* ------------------ for SetStaticOpArgPreCastHook ----------------------- */

inline static PyObject* static_op_arg_pre_cast_hook_get();

inline static void static_op_arg_pre_cast_hook_set(PyObject* obj);

static PyObject* set_static_op_arg_pre_cast_hook(PyObject* new_callback,
                                                 PyThreadState* tstate);

PyObject* SetStaticOpArgPreCastHook(PyObject* callback);

PyMODINIT_FUNC PyInit__static_op_arg_pre_cast_hook();

/* ------------------ for auto parallel ----------------------- */
void BindEagerUtils(PyObject* module);

std::tuple<std::vector<int64_t>,
           paddle::flat_hash_map<int64_t, phi::ReduceType>>
CvtPlacements(phi::distributed::Placements placements, int ndim);

void EagerSetDeviceId();

paddle::optional<Tensor*> GetInputOutTensorFromKwargs(PyObject* kwargs);

paddle::optional<std::tuple<Tensor*, Tensor*>>
GetPredefinedOutTupleTensorFromKwargs_2(PyObject* kwargs);
paddle::optional<std::tuple<Tensor*, Tensor*, Tensor*>>
GetPredefinedOutTupleTensorFromKwargs_3(PyObject* kwargs);
paddle::optional<std::tuple<Tensor*, Tensor*, Tensor*, Tensor*>>
GetPredefinedOutTupleTensorFromKwargs_4(PyObject* kwargs);
paddle::optional<std::tuple<Tensor*, Tensor*, Tensor*, Tensor*, Tensor*>>
GetPredefinedOutTupleTensorFromKwargs_5(PyObject* kwargs);
paddle::optional<
    std::tuple<Tensor*, Tensor*, Tensor*, Tensor*, Tensor*, Tensor*>>
GetPredefinedOutTupleTensorFromKwargs_6(PyObject* kwargs);
paddle::optional<
    std::tuple<Tensor*, Tensor*, Tensor*, Tensor*, Tensor*, Tensor*, Tensor*>>
GetPredefinedOutTupleTensorFromKwargs_7(PyObject* kwargs);

void Check_PIR_not_support_out(PyObject* kwargs);

std::unordered_map<std::string, std::string> ParseStringDict(PyObject* py_dict);

std::unordered_map<std::string, void*> ParsePythonOpAttrs(PyObject* py_dict);
/*----------------------for arg parse-----------------------------*/
Tensor& GetTensorFromArgsOrKWArgs(const std::string& op_type,
                                  const std::string& arg_name,
                                  PyObject* args,
                                  ssize_t arg_idx,
                                  PyObject* kwargs,
                                  const std::vector<std::string>& keywords,
                                  const int nargs,
                                  int* remaining_kwargs,
                                  bool dispensable = false);
}  // namespace pybind
}  // namespace paddle