2021-06-22mindspore代码标注3

mindsporemindsporeccsrcpipelinejitparsedate_couversion.cc代码标注3

namespace {//创建一个namespace空间
ValuePtr ConvertTuple(const py::object &obj, bool use_signature) {//输出转换元组
  MS_LOG(DEBUG) << "Converting python tuple";
  auto tuple = obj.cast<py::tuple>();//调用cast方法并将值返回给tuple
  std::vector<ValuePtr> value_list;//定义成员变量
  for (size_t it = 0; it < tuple.size(); ++it) {
    ValuePtr out = nullptr;//变量初始化赋值
    bool success = ConvertData(+, use_signature);//调用ConvertData函数的同时，赋值两个成员变量，并将结果返回到这里判断布尔值属性
    if (!success) {
      return nullptr;
    }
    value_list.push_back(out);
  }
  return std::make_shared<ValueTuple>(value_list);//返回值
}

ValuePtr ConvertList(const py::object &obj, bool use_signature) {//输出转换列表
  MS_LOG(DEBUG) << "Converting python list";

  auto list = obj.cast<py::list>();//给变量重新起个别名
  std::vector<ValuePtr> value_list;//定义一个成员变量
  for (size_t it = 0; it < list.size(); ++it) {
    ValuePtr out = nullptr;//变量初始化
    bool success = ConvertData(list[it], &out, use_signature);//调用ConvertData函数的同时，赋值两个成员变量，并将结果返回到这里判断布尔值属性
    if (!success) {
      return nullptr;
    }
    value_list.push_back(out);//调用方法
  }
  return std::make_shared<ValueList>(value_list);//返回值
}

ValuePtr ConvertCellList(const py::object &obj, bool use_signature) {//转换单元格列表
  MS_LOG(DEBUG) << "Converting cell list";
  py::sequence list = obj//给变量赋值
  std::vector<ValuePtr> value_list;//定义一个成员变量
  for (size_t it = 0; it < list.size(); ++it) {
    ValuePtr out = nullptr;//变量初始化
    bool success = ConvertData(list[it], &out, use_signature);//调用ConvertData函数的同时，赋值两个成员变量，并将结果返回到这里判断布尔值属性
    if (!success) {
      return nullptr;
    }
    value_list.push_back(out);//调用方法
  }
  return std::make_shared<ValueTuple>(value_list);//返回值
}

ValuePtr ConvertDict(const py::object &obj, bool use_signature) {
  MS_LOG(DEBUG) << "Converting python dict";

  auto dict_values = obj.cast<py::dict>();
  std::vector<std::pair<std::string, ValuePtr>> key_values;//将前一个变量的值输入给后一个变量
  for (auto item : dict_values) {
    if (!py::isinstance<py::str>(item.first)) {
      MS_LOG(ERROR) << "The key of dict is only support str.";//s
      return nullptr;
    }
    std::string key = py::str(item.first);
    ValuePtr out = nullptr;//初始化变量
    bool success = ConvertData(dict_values[item.first], &out, use_signature);
    if (!success) {
      return nullptr;
    }
    key_values.emplace_back(key, out);//调用方法
  }
  return std::make_shared<ValueDictionary>(key_values);//返回值
}
ValuePtr ConvertNameSpace(const py::object &obj) {//转换命名空间
  MS_LOG(DEBUG) << "Converting python module";
  py::module mod = python_adapter::GetPyModule(PYTHON_MOD_PARSE_MODULE);//给变量起个别名
  py::object module_namespace = python_adapter::CallPyModFn(mod, PYTHON_MOD_GET_MODULE_NAMESPACE, obj);//给变量起个别名
  auto converted = std::make_shared<NameSpace>(RESOLVE_NAMESPACE_NAME_MODULE, py::cast<py::module>(module_namespace));//变量声明
  return converted;//返回值
}

ValuePtr ConvertDataClass(const py::object &obj) {//创建一个类
  MS_LOG(DEBUG) << "Converting dataclass";//输出
  // Maybe the obj is dataclass define
  auto desc = py::cast<std::string>(python_adapter::CallPyObjMethod(obj, PYTHON_GET_OBJ_DESC, obj));//变量声明
  // desc has format "<class xxxx>", strip the '<' and '>' by offset 1;
  auto converted = std::make_shared<ClassObject>(obj, std::string(desc.begin() + 1, desc.end() - 1));//变量声明
  return converted;//输出
}

ValuePtr ConvertPrimitive(const py::object &obj, bool use_signature = false) {//创建一个类
  MS_LOG(DEBUG) << "Converting primitive object" << use_signature;//输出......

  // need check the primitive is class type or instance
  auto obj_type = data_converter::GetObjType(obj);//变量声明
  if (obj_type == RESOLVE_TYPE_CLASS_TYPE) {
    auto desc = py::cast<std::string>(python_adapter::CallPyObjMethod(obj, PYTHON_GET_OBJ_DESC, obj));//变量声明
    // desc has format "<class xxxx>", strip the '<' and '>' by offset 1;
    return std::make_shared<ClassType>(obj, std::string(desc.begin() + 1, desc.end() - 1));//返回值
  }
  py::object adapter_obj = obj;
  if (py::hasattr(obj, "__setattr_flag__")) {
    if (py::hasattr(obj, "_clone")) {
      auto clone_fn = obj.attr("_clone");//调用函数并附初值，并将结果返回赋给clone_fn 
      adapter_obj = clone_fn();//调用函数并将返回值赋给adapter_obj 
    }
  }
  auto prim_adapter = adapter_obj.cast<PrimitivePyAdapterPtr>();//调用函数并将返回值赋给prim_adapter
  MS_EXCEPTION_IF_NULL(prim_adapter);//定义一个成员变量
  auto primitive = prim_adapter->attached_primitive();//运用指针调用函数并附初值，并将结果返回赋给primitive
  if (primitive == nullptr) {//如果primitive为空，执行循环体语句
    primitive = std::make_shared<PrimitivePy>(adapter_obj, prim_adapter);//调用函数并赋给成员变量赋一个初值，然后将返回值赋给primitive 
    prim_adapter->set_attached_primitive(primitive);//指针调用函数并赋给成员变量赋一个初值
  }

  if (use_signature) {
    return std::make_shared<prim::DoSignaturePrimitive>(primitive->name(), primitive);//返回值
  }
  return primitive;//返回值
}

ValuePtr ConvertMetaFuncGraph(const py::object &obj, bool use_signature = false) {//转换元函数
  MS_LOG(DEBUG) << "Converting MetaFuncGraph object";//输出
  auto meta = obj.cast<MetaFuncGraphPtr>();//调用函数并附初值，并将结果返回赋给clone_fn 
  if (meta == nullptr) {//如果primitive为空，执行循环体语句
    MS_LOG(ERROR) << "Resolve MetaFuncGraph error, get ptr is null";
    return nullptr;
  }
  if (use_signature) {
    return std::make_shared<prim::DoSignaturePrimitive>(meta->name(), meta);//返回值
  }
  return meta;//返回值
}