qwak-sdk 0.5.30__tar.gz → 0.5.32__tar.gz

{qwak_sdk-0.5.30 → qwak_sdk-0.5.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qwak-sdk
-Version: 0.5.30
+Version: 0.5.32
 Summary: Qwak SDK and CLI for qwak models
 License: Apache-2.0
 Keywords: mlops,ml,deployment,serving,model
@@ -21,13 +21,14 @@ Provides-Extra: batch
 Provides-Extra: feedback
 Requires-Dist: boto3 (>=1.24.116,<2.0.0) ; extra == "batch" or extra == "feedback"
 Requires-Dist: cookiecutter
+Requires-Dist: croniter (==1.4.1)
 Requires-Dist: gitpython (>=2.1.0)
 Requires-Dist: joblib (>=1.1.0,<2.0.0) ; extra == "batch" or extra == "feedback"
 Requires-Dist: pandas (<1.4) ; (python_full_version >= "3.7.1" and python_version < "3.8") and (extra == "batch" or extra == "feedback")
 Requires-Dist: pandas (>=1.4.3,<2.0.0) ; (python_version >= "3.8" and python_version < "3.10") and (extra == "batch" or extra == "feedback")
 Requires-Dist: pyarrow (>=6.0.0,<11.0.0) ; extra == "batch"
 Requires-Dist: python-json-logger (>=2.0.2)
-Requires-Dist: qwak-core (==0.1.12)
+Requires-Dist: qwak-core (==0.1.36)
 Requires-Dist: qwak-inference (==0.1.8)
 Requires-Dist: tabulate (>=0.8.0)
 Requires-Dist: yaspin (>=2.0.0)

{qwak_sdk-0.5.30 → qwak_sdk-0.5.32}/pyproject.toml

@@ -1,12 +1,12 @@
 [tool.poetry]
 name = "qwak-sdk"
-version = "0.5.30"
+version = "0.5.32"
 description = "Qwak SDK and CLI for qwak models"
 authors = ["Qwak <info@qwak.com>"]
 readme = "README.md"
 keywords = ["mlops", "ml", "deployment", "serving", "model"]
 packages = [
-    {include = "qwak_sdk"},
+    { include = "qwak_sdk" },
 ]
 include = ["./qwak_sdk/**/*"]
 classifiers = [
@@ -27,20 +27,21 @@ qwak = "qwak_sdk.main:qwak_cli"
 
 [tool.poetry.dependencies]
 python = ">=3.7.1,<3.10"
-qwak-core = "==0.1.12"
+qwak-core = "==0.1.36"
 qwak-inference = "==0.1.8"
+croniter = "==1.4.1"
 tabulate = ">=0.8.0"
 python-json-logger = ">=2.0.2"
 yaspin = ">=2.0.0"
 cookiecutter = "*"
 gitpython = ">=2.1.0"
-boto3 = { version="^1.24.116", optional=true } # Inference dependencies
-pandas = [ # Inference dependencies
-    {version="<1.4", python=">=3.7.1,<3.8", optional=true},
-    {version=">=1.4.3,<2.0.0", python=">=3.8,<3.10", optional=true}
+boto3 = { version = "^1.24.116", optional = true } # Inference dependencies
+pandas = [# Inference dependencies
+    { version = "<1.4", python = ">=3.7.1,<3.8", optional = true },
+    { version = ">=1.4.3,<2.0.0", python = ">=3.8,<3.10", optional = true }
 ]
-joblib = { version="^1.1.0", optional=true } # Inference dependencies
-pyarrow = { version=">=6.0.0, <11.0.0", optional=true } # Inference dependencies
+joblib = { version = "^1.1.0", optional = true } # Inference dependencies
+pyarrow = { version = ">=6.0.0, <11.0.0", optional = true } # Inference dependencies
 
 [tool.poetry.group.dev.dependencies]
 pytest = "7.2.1"
@@ -48,9 +49,9 @@ pytest-lazy-fixture = "^0.6.3"
 assertpy = "^1.1"
 black = "23.1.0"
 flake8 = "5.0.0"
-bandit = {version = "^1.7.4", extras=["toml"]}
+bandit = { version = "^1.7.4", extras = ["toml"] }
 coverage = "7.2.1"
-typing_extensions ="4.4.0"
+typing_extensions = "4.4.0"
 bump2version = "1.0.1"
 typeguard = "^2"
 isort = "^5"
@@ -86,10 +87,10 @@ profile = "black"
 src_paths = ["qwak_sdk", "tests"]
 
 [tool.poe.tasks]
-clean = { cmd="rm -rf dist ./**/__pycache__", help="Clean build artifacts" }
+clean = { cmd = "rm -rf dist ./**/__pycache__", help = "Clean build artifacts" }
 install = "poetry install"
-validate = { cmd="pre-commit run  --all-files", help="Check lint on all files" }
-test = { cmd="pytest --disable-warnings tests", help="Run tests" }
+validate = { cmd = "pre-commit run  --all-files", help = "Check lint on all files" }
+test = { cmd = "pytest --disable-warnings tests", help = "Run tests" }
 
 [build-system]
 requires = ["poetry-core>=1.0.0"]

{qwak_sdk-0.5.30 → qwak_sdk-0.5.32}/qwak_sdk/__init__.py

@@ -1,6 +1,6 @@
 # fmt: off
 __author__ = '''Qwak.ai'''
-__version__ = '0.5.30'
+__version__ = '0.5.32'
 
 from qwak.inner import wire_dependencies
 

qwak_sdk-0.5.32/qwak_sdk/commands/feature_store/backfill/_logic.py

@@ -0,0 +1,140 @@
+from datetime import datetime, timezone
+from typing import Optional
+
+from _qwak_proto.qwak.feature_store.features.feature_set_pb2 import FeatureSet
+from _qwak_proto.qwak.feature_store.features.feature_set_service_pb2 import (
+    GetFeatureSetByNameResponse,
+)
+from croniter import croniter
+from qwak.clients.feature_store import FeatureRegistryClient
+from qwak.feature_store.execution.backfill import Backfill
+from qwak.feature_store.feature_sets.batch import BatchFeatureSetV1
+
+from qwak_sdk.inner.tools.cli_tools import ask_yesno
+from qwak_sdk.tools.colors import Color
+
+
+class _BackfillLogic:
+    featureset: FeatureSet
+    batch_featureset: BatchFeatureSetV1
+
+    def configure_window_backfill(
+        self,
+        featureset_name: str,
+        start_time: Optional[datetime] = None,
+        stop_time: Optional[datetime] = None,
+        comment: str = None,
+        cluster_template: str = None,
+    ) -> Optional[Backfill]:
+        """
+        Configures a window back-fill object. This type of backfill will not reset the entire featureset, but will be
+        performed from the requested start time to the requested stop time in ticks calculated according to the
+        feature sets scheduling policy.
+        @param featureset_name: feature set name to perform the backfill job for
+        @type featureset_name: str
+        @param start_time: backfill requested start date
+        @type start_time: optional[datetime]
+        @param stop_time:
+        @type stop_time: optional[datetime]
+        @param comment:
+        @type comment: str
+        @param cluster_template:
+        @type cluster_template: str
+        @return:
+        @rtype:
+        """
+        print(
+            f"{Color.BLUE} Backfilling from {start_time} to {stop_time}, "
+            f"the following ticks are going to be performed {Color.END}"
+        )
+        zipped_tick_strs = Backfill.generate_expected_ticks_repr(
+            scheduling_policy=self.batch_featureset.scheduling_policy,
+            start_time=start_time,
+            stop_time=stop_time,
+        )
+        print("\n".join(zipped_tick_strs))
+        if ask_yesno("", force=False):
+            backfill_execution = Backfill(
+                featureset_name=featureset_name,
+                comment=comment,
+                cluster_template=cluster_template,
+                start_time=start_time,
+                stop_time=stop_time,
+            )
+            return backfill_execution
+        return None
+
+    @staticmethod
+    def _get_featureset_by_name(featureset_name: str) -> GetFeatureSetByNameResponse:
+        registry_client = FeatureRegistryClient()
+
+        return registry_client.get_feature_set_by_name(feature_set_name=featureset_name)
+
+    def get_start_stop_times(
+        self,
+        requested_start_time: Optional[datetime] = None,
+        requested_stop_time: Optional[datetime] = None,
+    ) -> tuple:
+        start_time: datetime = (
+            requested_start_time or self.batch_featureset.backfill.start_date
+        ).replace(tzinfo=timezone.utc)
+        stop_time: datetime
+
+        if start_time and start_time > datetime.now().replace(tzinfo=timezone.utc):
+            stop_time = datetime.utcnow().replace(tzinfo=timezone.utc)
+        else:
+            stop_time = (
+                requested_stop_time or datetime.utcnow().replace(tzinfo=timezone.utc)
+            ).replace(tzinfo=timezone.utc)
+
+        return start_time, stop_time
+
+    def is_valid_input(
+        self,
+        reset_backfill: bool,
+        start_time: Optional[datetime],
+        stop_time: Optional[datetime],
+        featureset_name: str,
+    ) -> bool:
+        # Validate reset_backfill or start and stop times
+        if (not reset_backfill and not start_time and not stop_time) or (
+            reset_backfill and (start_time or stop_time)
+        ):
+            print(
+                f"{Color.RED} please specify either --reset-backfill or one or more of --start-time/--stop-time"
+            )
+            return False
+
+        # Validate featureset exists
+        get_featureset_resp = self._get_featureset_by_name(
+            featureset_name=featureset_name
+        )
+        if not get_featureset_resp or not get_featureset_resp.feature_set:
+            print(f"{Color.RED} Failed to retrieve featureset {featureset_name}")
+            return False
+
+        self.featureset = get_featureset_resp.feature_set
+        fs_type_attr: str = self.featureset.feature_set_definition.feature_set_spec.feature_set_type.WhichOneof(
+            "set_type"
+        )
+        # Validate featureset is batch v1
+        if fs_type_attr != "batch_feature_set_v1":
+            print(
+                f"{Color.RED} Feature set {featureset_name} is of type {fs_type_attr}. Only BatchV1 is supported."
+            )
+            return False
+
+        self.batch_featureset = BatchFeatureSetV1.from_proto(
+            self.featureset.feature_set_definition.feature_set_spec
+        )
+
+        # Validate scheduling policy
+        if not self.batch_featureset.scheduling_policy or not croniter.is_valid(
+            self.batch_featureset.scheduling_policy
+        ):
+            print(
+                f"{Color.RED} Feature set {featureset_name} has an invalid scheduling policy {self.batch_featureset.scheduling_policy}."
+            )
+            return False
+
+        return True

qwak_sdk-0.5.32/qwak_sdk/commands/feature_store/backfill/ui.py

@@ -0,0 +1,129 @@
+from datetime import datetime
+from typing import Optional
+
+import click
+from qwak.feature_store.execution.backfill import Backfill
+
+from qwak_sdk.commands.feature_store.backfill._logic import _BackfillLogic
+from qwak_sdk.inner.tools.cli_tools import QwakCommand, ask_yesno
+from qwak_sdk.tools.colors import Color
+
+
+@click.command(
+    "backfill", cls=QwakCommand, help="Trigger a backfill process for a Feature Set"
+)
+@click.option(
+    "--feature-set",
+    "--name",
+    help="Feature Set name to perform the backfill process for",
+    required=True,
+    type=click.STRING,
+)
+@click.option(
+    "--reset-backfill",
+    "--reset",
+    is_flag=True,
+    metavar="FLAG",
+    default=False,
+    help="Perform a complete reset of the featuresets data. "
+    "This will result in the deletion of the current existing data.",
+)
+@click.option(
+    "--start-time",
+    type=click.DateTime(),
+    default=None,
+    required=False,
+    help="The time from which the featuresets data should be backfilled in UTC. "
+    "Defaults to the featuresets configured backfill start time.",
+)
+@click.option(
+    "--stop-time",
+    type=click.DateTime(),
+    default=None,
+    required=False,
+    help="The time up until the featuresets data should be backfilled in UTC. Defaults to the current timestamp. "
+    "If the time provided is in the future, stop time will be rounded down to the current time. ",
+)
+@click.option(
+    "--cluster-template",
+    type=str,
+    default=None,
+    required=False,
+    help="Backfill resource configuration, expects a ClusterType size. "
+    "Defaults to the featureset resource configuration",
+)
+@click.option(
+    "--comment",
+    type=str,
+    default=None,
+    required=False,
+    help="Backfill job optional comment tag line",
+)
+def backfill(
+    feature_set: str,
+    reset_backfill: bool,
+    start_time: Optional[datetime],
+    stop_time: Optional[datetime],
+    cluster_template: Optional[str],
+    comment: Optional[str],
+    **kwargs,
+):
+    backill_logic = _BackfillLogic()
+    if not backill_logic.is_valid_input(
+        reset_backfill=reset_backfill,
+        start_time=start_time,
+        stop_time=stop_time,
+        featureset_name=feature_set,
+    ):
+        return
+
+    if reset_backfill:
+        backfill_execution = _configure_backfill_triggered(
+            featureset_name=feature_set,
+            comment=comment,
+            cluster_template=cluster_template,
+        )
+    else:
+        start, stop = backill_logic.get_start_stop_times(
+            requested_start_time=start_time, requested_stop_time=stop_time
+        )
+        if start >= stop:
+            print(
+                f"{Color.RED} Stop time {stop.isoformat()} must be after start time {start.isoformat()}"
+            )
+            return
+
+        backfill_execution = backill_logic.configure_window_backfill(
+            featureset_name=feature_set,
+            start_time=start,
+            stop_time=stop,
+            comment=comment,
+            cluster_template=cluster_template,
+        )
+
+    if backfill_execution:
+        execution_id: str = backfill_execution.trigger_batch_backfill()
+        print(
+            f"{Color.BLUE}✅  Triggered backfill execution for featureset {feature_set}, "
+            f"execution id for follow up on is {execution_id}."
+        )
+        print(
+            f"To inquire the status of the execution run "
+            f"'qwak features execution-status --execution-id {execution_id}'"
+        )
+
+
+def _configure_backfill_triggered(
+    featureset_name: str, comment: str, cluster_template: str
+) -> Optional[Backfill]:
+    if ask_yesno(
+        f"You are about to remove and re-populate all data in {featureset_name}",
+        force=False,
+    ):
+        print(f"{Color.RED} - A backfill reset was triggered")
+        return Backfill(
+            featureset_name=featureset_name,
+            comment=comment,
+            cluster_template=cluster_template,
+        )
+    return None

qwak_sdk-0.5.32/qwak_sdk/commands/feature_store/execution/ui.py

@@ -0,0 +1,19 @@
+import click
+from qwak.feature_store.execution.execution_query import ExecutionQuery
+
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+
+@click.command(
+    "execution-status",
+    cls=QwakCommand,
+    help="Retrieve the current status of an execution (backfill/batch job ingestion)",
+)
+@click.option(
+    "--execution-id",
+    type=str,
+    required=True,
+    help="The id of the execution to retrieve the status for.",
+)
+def execution_status(execution_id: str, **kwargs):
+    print(ExecutionQuery.get_execution_status_message(execution_id=execution_id))

{qwak_sdk-0.5.30 → qwak_sdk-0.5.32}/qwak_sdk/commands/feature_store/feature_store_command_group.py

@@ -1,6 +1,8 @@
 import click
 
+from qwak_sdk.commands.feature_store.backfill.ui import backfill
 from qwak_sdk.commands.feature_store.delete.ui import delete_fs_object
+from qwak_sdk.commands.feature_store.execution.ui import execution_status
 from qwak_sdk.commands.feature_store.list.ui import list_feature_sets
 from qwak_sdk.commands.feature_store.pause.ui import pause_feature_set
 from qwak_sdk.commands.feature_store.register.ui import register_fs_objects
@@ -23,3 +25,5 @@ feature_store_commands_group.add_command(pause_feature_set)
 feature_store_commands_group.add_command(resume_feature_set)
 feature_store_commands_group.add_command(trigger_feature_set)
 feature_store_commands_group.add_command(register_fs_objects)
+feature_store_commands_group.add_command(backfill)
+feature_store_commands_group.add_command(execution_status)

{qwak_sdk-0.5.30 → qwak_sdk-0.5.32}/qwak_sdk/commands/models/build/_logic/client_logs/logger.py

@@ -29,6 +29,7 @@ from qwak_sdk.inner.tools.logger.logger import (
 BUILDS_LOGS = HOST_QWAK_HIDDEN_FOLDER / "logs" / "build"
 BUILD_LOG_NAME = "build.log"
 MAX_LOGS_NUMBER = 15
+DEBUG_LEVEL = 2
 
 
 @contextlib.contextmanager
@@ -76,7 +77,7 @@ def setup_logger(
             set_handler_verbosity(
                 logger,
                 REMOTE_CONSOLE_HANDLER_NAME,
-                VERBOSITY_LEVEL_MAPPING[verbosity_level],
+                VERBOSITY_LEVEL_MAPPING[DEBUG_LEVEL],
             )
 
     return logger

qwak_sdk-0.5.32/qwak_sdk/commands/models/builds/status/_logic.py

@@ -0,0 +1,6 @@
+from _qwak_proto.qwak.builds.builds_pb2 import BuildStatus
+from qwak.clients.build_orchestrator import BuildOrchestratorClient
+
+
+def execute_get_build_status(build_id) -> BuildStatus:
+    return BuildOrchestratorClient().get_build(build_id).build.build_status

{qwak_sdk-0.5.30 → qwak_sdk-0.5.32}/qwak_sdk/commands/models/deployments/deploy/_logic/get_latest_successful_build.py

@@ -1,7 +1,5 @@
-from copy import deepcopy
-
 from _qwak_proto.qwak.builds.builds_pb2 import SUCCESSFUL
-from qwak.clients.build_management.client import BuildsManagementClient
+from qwak.clients.build_orchestrator import BuildOrchestratorClient
 from qwak.clients.model_management.client import ModelsManagementClient
 from qwak.exceptions import QwakException
 
@@ -20,12 +18,11 @@ def get_latest_successful_build_from_model(model_id: str) -> str:
     """
     model = ModelsManagementClient().get_model(model_id)
     model_uuid = model.uuid
-    last_successful_build = BuildsManagementClient().list_builds(model_uuid)
-    builds = deepcopy(last_successful_build.builds)
-    builds = [build for build in builds if build.build_status == SUCCESSFUL]
-    builds.sort(key=lambda r: r.created_at.seconds)
+    all_builds = BuildOrchestratorClient().list_builds(model_uuid).build
+    builds = [build for build in all_builds if build.build_status == SUCCESSFUL]
+    builds.sort(key=lambda r: r.audit.created_at.seconds)
 
     if not builds:
         raise QwakException(f"Unable to find successful build for model {model_id}")
 
-    return builds[-1].build_spec.build_id
+    return builds[-1].buildId

{qwak_sdk-0.5.30 → qwak_sdk-0.5.32}/qwak_sdk/commands/models/deployments/undeploy/_logic/request_undeploy.py

@@ -1,3 +1,4 @@
+from time import sleep
 from typing import Dict, List, Set
 
 from _qwak_proto.qwak.audience.v1.audience_pb2 import AudienceRoutesEntry
@@ -24,13 +25,19 @@ from qwak_sdk.commands.models.deployments.deploy._logic.deploy_config import (
 from qwak_sdk.commands.models.deployments.undeploy._logic.variations import (
     validate_variations_for_undeploy,
 )
+from qwak_sdk.tools.utils import qwak_spinner
 
 NO_DEPLOYED_VARIATIONS_ERROR_MSG = (
     "There are currently no deployed variations for model {model_id} in {env_name}"
 )
-
+UNDEPLOY_ERROR_MSG = "Environment {environment_id} failed with status: {status}"
 logger = get_qwak_logger()
 
+FAILED_UNDEPLOYMENT_STATUS = ["FAILED_UNDEPLOYMENT"]
+SUCCESSFUL_UNDEPLOYMENT_STATUS = ["SUCCESSFUL_UNDEPLOYMENT"]
+END_UNDEPLOYMENT_STATUSES = SUCCESSFUL_UNDEPLOYMENT_STATUS + FAILED_UNDEPLOYMENT_STATUS
+TIME_TO_WAIT_FOR_UNDEPLOYMENT_POLLING = 5
+
 
 def get_deployed_variation_name(existing_variations_names: Set[str]) -> str:
     return list(existing_variations_names)[0]
@@ -123,6 +130,7 @@ def undeploy(
     model_id: str,
     config: DeployConfig,
     model_uuid: str = "",
+    sync: bool = False,
 ):
     deployment_client = DeploymentManagementClient()
     ecosystem_client = EcosystemClient()
@@ -161,14 +169,108 @@ def undeploy(
         config.realtime.fallback_variation,
     )
 
+    environment_to_deployment_id = {}
+    if sync:
+        environment_to_deployment_id = __get_environment_to_deployment_id(
+            deployment_client, model_id, model_uuid, env_undeployment_requests
+        )
+
     undeployment_response = deployment_client.undeploy_model(
         model_id=model_id,
         model_uuid=model_uuid,
         env_undeployment_requests=env_undeployment_requests,
     )
 
+    if sync:
+        __sync_undeploy(
+            environment_to_deployment_id=environment_to_deployment_id,
+            model_id=model_id,
+            deployment_client=deployment_client,
+        )
     logger.info(
         f"Current status is {ModelDeploymentStatus.Name(undeployment_response.status)}."
     )
 
     return undeployment_response
+
+
+def __get_environment_to_deployment_id(
+    deployment_client: DeploymentManagementClient,
+    model_id: str,
+    model_uuid: str,
+    env_undeployment_requests: Dict,
+) -> Dict:
+    deployment_details = deployment_client.get_deployment_details(
+        model_id, model_uuid
+    ).environment_to_deployment_details
+    result = {}
+    for env_id, env_deployment_details in env_undeployment_requests.items():
+        deployment_detail_by_env = deployment_details.get(env_id)
+        if deployment_detail_by_env:
+            for deployment_detail in deployment_detail_by_env.deployments_details:
+                if (
+                    env_id == deployment_detail.environment_id
+                    and deployment_detail.variation.name
+                    == env_deployment_details.traffic_config.selected_variation_name
+                ):
+                    result[env_id] = deployment_detail.deployment_id
+    return result
+
+
+def __sync_undeploy(
+    environment_to_deployment_id: Dict,
+    model_id: str,
+    deployment_client: DeploymentManagementClient,
+):
+    with qwak_spinner(
+        begin_text=f"Undeploy - model: {model_id}",
+        end_text="Successful undeployment",
+        print_callback=print,
+    ):
+        for environment_id, deployment_id in environment_to_deployment_id.items():
+            status_result = _poll_undeployment_status(
+                deployment_id=deployment_id,
+                deployment_client=deployment_client,
+                check_every_n_seconds=TIME_TO_WAIT_FOR_UNDEPLOYMENT_POLLING,
+            )
+            failed_to_undeployment = []
+            for _, status in status_result.items():
+                if status in FAILED_UNDEPLOYMENT_STATUS:
+                    failed_to_undeployment.append(
+                        UNDEPLOY_ERROR_MSG.format(
+                            environment_id=environment_id, status=status
+                        )
+                    )
+            if failed_to_undeployment:
+                raise QwakException("\n".join(failed_to_undeployment))
+
+
+def _poll_undeployment_status(
+    deployment_id: str,
+    deployment_client: DeploymentManagementClient,
+    check_every_n_seconds: int,
+) -> Dict:
+    deployment_status = ""
+
+    while deployment_status not in END_UNDEPLOYMENT_STATUSES:
+        sleep(check_every_n_seconds)
+        deployment_status = __get_deployment_status(
+            deployment_id=deployment_id, deployment_client=deployment_client
+        )
+    return {deployment_id: deployment_status}
+
+
+def __get_deployment_status(
+    deployment_id: str, deployment_client: DeploymentManagementClient
+):
+    try:
+        return ModelDeploymentStatus.Name(
+            deployment_client.get_deployment_status(
+                deployment_named_id=deployment_id,
+            ).status
+        )
+    except QwakException as e:
+        logger.error(
+            f"Got error while trying to get deployment id: {deployment_id} status. Error is: {e.message}"
+        )
+        return ""

{qwak_sdk-0.5.30 → qwak_sdk-0.5.32}/qwak_sdk/commands/models/deployments/undeploy/ui.py

@@ -42,11 +42,18 @@ logger = get_qwak_logger()
     required=False,
     type=click.Path(exists=True, resolve_path=True, dir_okay=False),
 )
+@click.option(
+    "--sync",
+    is_flag=True,
+    default=False,
+    help="Waiting for deployments to be undeploy",
+)
 def models_undeploy(
     model_id: str,
     variation_name: str,
     environment_name: List[str],
     from_file: str = None,
+    sync: bool = False,
     **kwargs,
 ):
     logger.info(f"Initiating undeployment for model '{model_id}'")
@@ -62,8 +69,4 @@ def models_undeploy(
     )
     model_uuid = models_management.get_model_uuid(model_id)
 
-    undeploy(
-        model_id=model_id,
-        config=config,
-        model_uuid=model_uuid,
-    )
+    undeploy(model_id=model_id, config=config, model_uuid=model_uuid, sync=sync)