Merge branch 'master' into feature-flip-preprocessing

Author: Ashitpatel001

.github/scripts/workflow_rerun/errors_to_look_for.json

@@ -8,7 +8,7 @@
         "ticket": 135715
     },
     {
-        "error_text": "error: RPC failed",
+        "error_text": "GnuTLS recv error",
         "ticket": 131918
     },
     {
@@ -87,18 +87,6 @@
         "error_text": "because the GET request got Content-Type",
         "ticket": 158400
     },
-    {
-        "error_text": "Unable to make request:",
-        "ticket": 158401
-    },
-    {
-        "error_text": "Failed to make request",
-        "ticket": 158401
-    },
-    {
-        "error_text": "Unable to download artifact",
-        "ticket": 158401
-    },
     {
         "error_text": "Failure when receiving data from the peer",
         "ticket": 159323
@@ -162,5 +150,33 @@
     {
         "error_text": "urllib3.exceptions.IncompleteRead",
         "ticket": 173184
+    },
+    {
+        "error_text": "Error from intermediary with HTTP status code 403",
+        "ticket": 181450
+    },
+    {
+        "error_text": "getaddrinfo EAI_AGAIN",
+        "ticket": 178917
+    },
+    {
+        "error_text": "terminal prompts disabled",
+        "ticket": 181095
+    },
+    {
+        "error_text": "HTTP 500 curl 22 The requested URL returned error: 500",
+        "ticket": 181530
+    },
+    {
+        "error_text": "Unable to make request: ECONNREFUSED",
+        "ticket": 158401
+    },
+    {
+        "error_text": "Unable to make request: ECONNRESET",
+        "ticket": 158401
+    },
+    {
+        "error_text": "Failed to FinalizeArtifact: Failed to make request after 5 attempts: Unexpected token",
+        "ticket": 181539
     }
 ]

.github/workflows/workflow_rerunner.yml

@@ -108,6 +108,6 @@ jobs:
 
           # Need to get a run id with successful status for log analyzing
           # cannot lock a run id as logs get deleted after some time
-          run_id=$(python3 -c "from github import Github, Auth; import os; github=Github(auth=Auth.Token(token=os.environ.get('GITHUB_TOKEN'))); repo = github.get_repo('${GITHUB_REPOSITORY}'); run_id = repo.get_workflow_runs(status='success')[0].id; print(run_id)")
+          run_id=$(python3 -c "from github import Github, Auth; import os; from datetime import datetime, timedelta, timezone; github=Github(auth=Auth.Token(token=os.environ.get('GITHUB_TOKEN'))); repo = github.get_repo('${GITHUB_REPOSITORY}'); cutoff_date=(datetime.now(timezone.utc)-timedelta(days=14)).date().isoformat(); runs=repo.get_workflow_runs(status='success', created=f'>={cutoff_date}'); print(runs[0].id)")
 
           python3 rerunner.py --repository-name ${GITHUB_REPOSITORY} --run-id $run_id --rerunner-run-id ${{ github.run_id }} --dry-run

cmake/features.cmake

@@ -117,7 +117,6 @@ else()
 endif()
 
 ov_dependent_option (ENABLE_TBBBIND_2_5 "Enable TBBBind_2_5 static usage in OpenVINO runtime" ${ENABLE_TBBBIND_2_5_DEFAULT} "THREADING MATCHES TBB; NOT APPLE" OFF)
-ov_dependent_option (ENABLE_TBB_RELEASE_ONLY "Only Release TBB libraries are linked to the OpenVINO Runtime binaries" ON "THREADING MATCHES TBB;LINUX" OFF)
 
 ov_option (ENABLE_MULTI "Enables MULTI Device Plugin" ON)
 ov_option (ENABLE_AUTO "Enables AUTO Device Plugin" ON)
@@ -144,7 +143,6 @@ ov_option(ENABLE_OV_PADDLE_FRONTEND "Enable PaddlePaddle FrontEnd" ON)
 ov_option(ENABLE_OV_IR_FRONTEND "Enable IR FrontEnd" ON)
 ov_option(ENABLE_OV_PYTORCH_FRONTEND "Enable PyTorch FrontEnd" ON)
 ov_option(ENABLE_OV_JAX_FRONTEND "Enable JAX FrontEnd" ON)
-ov_option(ENABLE_OV_IR_FRONTEND "Enable IR FrontEnd" ON)
 ov_option(ENABLE_OV_TF_FRONTEND "Enable TensorFlow FrontEnd" ON)
 ov_option(ENABLE_OV_TF_LITE_FRONTEND "Enable TensorFlow Lite FrontEnd" ON)
 
@@ -224,10 +222,6 @@ if(ENABLE_OPENVINO_DEBUG)
     add_definitions(-DENABLE_OPENVINO_DEBUG)
 endif()
 
-if (ENABLE_PROFILING_RAW)
-    add_definitions(-DENABLE_PROFILING_RAW=1)
-endif()
-
 if (ENABLE_SNIPPETS_DEBUG_CAPS)
     add_definitions(-DSNIPPETS_DEBUG_CAPS)
 endif()

src/bindings/js/node/include/core_wrap.hpp

@@ -128,7 +128,7 @@ struct TsfnContextPath {
     Napi::Promise::Deferred deferred;
     Napi::ThreadSafeFunction tsfn;
 
-    std::string _model;
+    std::filesystem::path _model;
     std::string _device;
     ov::CompiledModel _compiled_model;
     std::map<std::string, ov::Any> _config = {};

src/bindings/js/node/include/helper.hpp

@@ -4,6 +4,7 @@
 #pragma once
 #include <napi.h>
 
+#include <filesystem>
 #include <unordered_set>
 #include <variant>
 
@@ -70,6 +71,10 @@ template <>
 ov::preprocess::ResizeAlgorithm js_to_cpp<ov::preprocess::ResizeAlgorithm>(const Napi::CallbackInfo& info,
                                                                            const size_t idx);
 
+/** @brief  A template specialization for TargetType std::filesystem::path */
+template <>
+std::filesystem::path js_to_cpp<std::filesystem::path>(const Napi::CallbackInfo& info, const size_t idx);
+
 /** @brief  A template specialization for TargetType ov::Any */
 template <>
 ov::Any js_to_cpp<ov::Any>(const Napi::Env& env, const Napi::Value& value);

src/bindings/js/node/include/read_model_args.hpp

@@ -1,3 +1,7 @@
+// Copyright (C) 2018-2026 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
 #pragma once
 
 #include <napi.h>
@@ -10,8 +14,8 @@
  * @brief This struct retrieves data from Napi::CallbackInfo.
  */
 struct ReadModelArgs {
-    std::string model_path;
-    std::string bin_path;
+    std::filesystem::path model_path;
+    std::filesystem::path bin_path;
     std::string model_str;
     ov::Tensor weight_tensor;
 
@@ -20,10 +24,10 @@ struct ReadModelArgs {
         std::vector<std::string> allowed_signatures;
 
         if (ov::js::validate<Napi::String>(info, allowed_signatures)) {
-            model_path = info[0].ToString();
+            model_path = js_to_cpp<std::filesystem::path>(info, 0);
         } else if (ov::js::validate<Napi::String, Napi::String>(info, allowed_signatures)) {
-            model_path = info[0].ToString();
-            bin_path = info[1].ToString();
+            model_path = js_to_cpp<std::filesystem::path>(info, 0);
+            bin_path = js_to_cpp<std::filesystem::path>(info, 1);
         } else if (ov::js::validate<Napi::Buffer<uint8_t>>(info, allowed_signatures)) {
             model_str = buffer_to_string(info[0]);
             weight_tensor = ov::Tensor(ov::element::Type_t::u8, {0});

src/bindings/js/node/src/addon.cpp

@@ -38,12 +38,12 @@ Napi::Value save_model_sync(const Napi::CallbackInfo& info) {
         if (ov::js::validate<ModelWrap, Napi::String>(info, allowed_signatures)) {
             const auto& model = info[0].ToObject();
             const auto m = Napi::ObjectWrap<ModelWrap>::Unwrap(model);
-            const auto path = js_to_cpp<std::string>(info, 1);
+            const auto path = js_to_cpp<std::filesystem::path>(info, 1);
             ov::save_model(m->get_model(), path);
         } else if (ov::js::validate<ModelWrap, Napi::String, Napi::Boolean>(info, allowed_signatures)) {
             const auto& model = info[0].ToObject();
             const auto m = Napi::ObjectWrap<ModelWrap>::Unwrap(model);
-            const auto path = js_to_cpp<std::string>(info, 1);
+            const auto path = js_to_cpp<std::filesystem::path>(info, 1);
             const auto compress_to_fp16 = info[2].ToBoolean();
             ov::save_model(m->get_model(), path, compress_to_fp16);
         } else {

src/bindings/js/node/src/core_wrap.cpp

@@ -69,7 +69,8 @@ Napi::Value CoreWrap::read_model_sync(const Napi::CallbackInfo& info) {
         std::shared_ptr<ov::Model> model;
 
         if (ov::js::validate<Napi::String, Napi::String>(info, allowed_signatures)) {
-            model = _core.read_model(info[0].ToString(), info[1].ToString());
+            model =
+                _core.read_model(js_to_cpp<std::filesystem::path>(info, 0), js_to_cpp<std::filesystem::path>(info, 1));
         } else if (ov::js::validate<Napi::Buffer<uint8_t>, Napi::Buffer<uint8_t>>(info, allowed_signatures)) {
             std::string model_str = buffer_to_string(info[0]);
 
@@ -87,7 +88,7 @@ Napi::Value CoreWrap::read_model_sync(const Napi::CallbackInfo& info) {
 
             model = _core.read_model(model_str, weight_tensor);
         } else if (ov::js::validate<Napi::String>(info, allowed_signatures)) {
-            model = _core.read_model(info[0].ToString());
+            model = _core.read_model(js_to_cpp<std::filesystem::path>(info, 0));
         } else if (ov::js::validate<Napi::String, TensorWrap>(info, allowed_signatures)) {
             model = _core.read_model(info[0].ToString(), cast_to_tensor(info, 1));
         } else {
@@ -131,13 +132,6 @@ Napi::Value CoreWrap::compile_model_sync(const Napi::CallbackInfo& info,
     }
 }
 
-Napi::Value CoreWrap::compile_model_sync(const Napi::CallbackInfo& info,
-                                         const Napi::String& model_path,
-                                         const Napi::String& device) {
-    const auto& compiled_model = _core.compile_model(model_path, device);
-    return CompiledModelWrap::wrap(info.Env(), compiled_model);
-}
-
 Napi::Value CoreWrap::compile_model_sync(const Napi::CallbackInfo& info,
                                          const Napi::Object& model_obj,
                                          const Napi::String& device,
@@ -147,26 +141,22 @@ Napi::Value CoreWrap::compile_model_sync(const Napi::CallbackInfo& info,
     return CompiledModelWrap::wrap(info.Env(), compiled_model);
 }
 
-Napi::Value CoreWrap::compile_model_sync(const Napi::CallbackInfo& info,
-                                         const Napi::String& model_path,
-                                         const Napi::String& device,
-                                         const std::map<std::string, ov::Any>& config) {
-    const auto& compiled_model = _core.compile_model(model_path, device, config);
-    return CompiledModelWrap::wrap(info.Env(), compiled_model);
-}
-
 Napi::Value CoreWrap::compile_model_sync_dispatch(const Napi::CallbackInfo& info) {
     std::vector<std::string> allowed_signatures;
 
     try {
         if (ov::js::validate<Napi::String, Napi::String>(info, allowed_signatures)) {
-            return compile_model_sync(info, info[0].ToString(), info[1].ToString());
+            const auto& compiled_model =
+                _core.compile_model(js_to_cpp<std::filesystem::path>(info, 0), info[1].ToString());
+            return CompiledModelWrap::wrap(info.Env(), compiled_model);
         } else if (ov::js::validate<ModelWrap, Napi::String>(info, allowed_signatures)) {
             return compile_model_sync(info, info[0].ToObject(), info[1].ToString());
         } else if (ov::js::validate<Napi::String, Napi::String, Napi::Object>(info, allowed_signatures)) {
             const auto& config = js_to_cpp<std::map<std::string, ov::Any>>(info, 2);
 
-            return compile_model_sync(info, info[0].ToString(), info[1].ToString(), config);
+            const auto& compiled_model =
+                _core.compile_model(js_to_cpp<std::filesystem::path>(info, 0), info[1].ToString(), config);
+            return CompiledModelWrap::wrap(info.Env(), compiled_model);
         } else if (ov::js::validate<ModelWrap, Napi::String, Napi::Object>(info, allowed_signatures)) {
             const auto& config = js_to_cpp<std::map<std::string, ov::Any>>(info, 2);
 
@@ -244,7 +234,7 @@ Napi::Value CoreWrap::compile_model_async(const Napi::CallbackInfo& info) {
         return context_data->deferred.Promise();
     } else if (info[0].IsString() && info[1].IsString()) {
         auto context_data = new TsfnContextPath(env);
-        context_data->_model = info[0].ToString();
+        context_data->_model = js_to_cpp<std::filesystem::path>(info, 0);
         context_data->_device = info[1].ToString();
 
         if (info.Length() == 3) {
@@ -473,8 +463,7 @@ void CoreWrap::add_extension(const Napi::CallbackInfo& info) {
         if (!info[0].IsString())
             OPENVINO_THROW("addExtension method applies one argument of string type");
 
-        std::string library_path = info[0].ToString();
-        _core.add_extension(library_path);
+        _core.add_extension(js_to_cpp<std::filesystem::path>(info, 0));
     } catch (std::runtime_error& err) {
         reportError(info.Env(), err.what());
     }

src/bindings/js/node/src/helper.cpp

@@ -151,6 +151,13 @@ ov::preprocess::ResizeAlgorithm js_to_cpp<ov::preprocess::ResizeAlgorithm>(const
     }
 }
 
+template <>
+std::filesystem::path js_to_cpp<std::filesystem::path>(const Napi::CallbackInfo& info, const size_t idx) {
+    const auto& path = info[idx];
+    OPENVINO_ASSERT(path.IsString(), "Passed argument must be of type String.");
+    return std::filesystem::path(path.ToString().Utf8Value());
+}
+
 template <>
 ov::Any js_to_cpp<ov::Any>(const Napi::Env& env, const Napi::Value& value) {
     if (value.IsString()) {

src/common/low_precision_transformations/src/low_precision.cpp

@@ -304,6 +304,7 @@ bool LowPrecision::run_on_model(const std::shared_ptr<ov::Model>& m) {
 
     REGISTER_PASS(manager, FoldFakeQuantizeTransformation, params)
     REGISTER_PASS(manager, ConstantFolding)
+    REGISTER_PASS(manager, Validate)
 
     manager.run_passes(m);
     return false;