thestage 0.6.6__py3-none-any.whl → 0.6.8__py3-none-any.whl

thestage/{services/clients/git → git/communication}/git_client.py

@@ -12,9 +12,9 @@ from gitdb.exc import BadName
 from rich import print
 
 from thestage.color_scheme.color_scheme import ColorScheme
-from thestage.config import THESTAGE_CONFIG_DIR
+from thestage.config.env_base import THESTAGE_CONFIG_DIR
 from thestage.exceptions.git_access_exception import GitAccessException
-from thestage.git.ProgressPrinter import ProgressPrinter
+from thestage.git.business.ProgressPrinter import ProgressPrinter
 from thestage.services.filesystem_service import FileSystemService
 
 
@@ -33,7 +33,7 @@ class GitLocalClient:
     ):
         self.__file_system_service = file_system_service
 
-    # todo delete this fuckery
+    # todo delete this
     def __get_repo(self, path: str) -> Repo:
         return git.Repo(path)
 
@@ -196,7 +196,7 @@ class GitLocalClient:
     ) -> Optional[str]:
         repo = self.__get_repo(path=path)
         if repo.head.is_detached:
-            line_color = ColorScheme.GIT_HEADLESS
+            line_color = ColorScheme.GIT_HEADLESS.value
             print(f'[{line_color}]Committing in detached head state at {repo.head.commit.hexsha}[/{line_color}]')
         commit_name = name if name else f"Auto commit {str(datetime.datetime.now().date())}"
         commit = repo.git.commit('--allow-empty', '-m', commit_name, )
@@ -392,7 +392,7 @@ class GitLocalClient:
                     repo.git.reset('--hard', f'origin/{repo.active_branch.name}')
                     typer.echo(f'Branch "{repo.active_branch.name}" is now synced to its remote counterpart')
                 else:
-                    typer.echo('simple branch reset is not implemented')
+                    typer.echo('Simple branch reset is not implemented')
 
     # refers to a "headless commit" where something was committed while in detached head state and head is pointing at that commit
     def is_head_committed_in_headless_state(self, path: str) -> bool:

thestage/helpers/error_handler.py

@@ -7,7 +7,7 @@ from click.exceptions import Exit, Abort
 from git import GitCommandError
 from paramiko.ssh_exception import PasswordRequiredException
 
-from thestage.config import THESTAGE_API_URL
+from thestage.config.env_base import THESTAGE_API_URL
 from thestage.exceptions.file_system_exception import FileSystemException
 from thestage.exceptions.remote_server_exception import RemoteServerException
 from thestage.i18n.translation import __
@@ -26,7 +26,7 @@ def error_handler() -> Callable:
                 result = f(*args, **kwargs)
                 return result
             except AuthException as e1:
-                typer.echo(__('Authentication failed: update API token'))
+                typer.echo(__('Authentication failed: update access token'))
                 app_logger.error(f'{traceback.format_exc()}')
                 raise typer.Exit(1)
             except BusinessLogicException as e2:
@@ -98,7 +98,7 @@ def error_handler() -> Callable:
                 raise typer.Exit(1)
             except PasswordRequiredException as e11:
                 # technically we can use encrypted keys but dealing with passwords is big bs
-                typer.echo("Provided key requires password. Please use non-encrypted key.")
+                typer.echo("Provided key requires password. Use non-encrypted key.")
                 app_logger.error(f'{traceback.format_exc()}')
                 raise typer.Exit(1)
             except Exception as e100:
@@ -106,8 +106,8 @@ def error_handler() -> Callable:
                     raise e100
                 else:
                     typer.echo(__('Undefined error occurred'))
-                    typer.echo(e100.__class__.__name__)
-                    print(traceback.format_exc())
+                    # typer.echo(e100.__class__.__name__)
+                    # print(traceback.format_exc())
                     # TODO send all exceptions to backend?
                     app_logger.error(f'{traceback.format_exc()}')
                     raise typer.Exit(1)

thestage/helpers/logger/app_logger.py

@@ -3,10 +3,8 @@ import platform
 from logging.handlers import RotatingFileHandler
 from pathlib import Path
 from thestage import __app_name__, __version__
+from thestage.config.env_base import THESTAGE_CONFIG_DIR, THESTAGE_LOGGING_FILE
 
-from thestage.config import THESTAGE_CONFIG_DIR
-
-from thestage.config import THESTAGE_LOGGING_FILE
 from thestage.exceptions.file_system_exception import FileSystemException
 
 

thestage/i18n/en_GB/messages.po

@@ -161,7 +161,7 @@ msgstr "Add URL to your own repository"
 
 # Branch: feature/add_new_method_for_containers
 #: tsr/controllers/sketch_controller.py
-msgid "This folder is not empty, we can not clone here"
+msgid "This folder is not empty, we cannot clone here"
 msgstr "Cannot clone: the folder is not empty"
 
 # Branch: feature/add_new_method_for_containers
@@ -362,7 +362,7 @@ msgstr "Task title is required: please type or select to auto-generate"
 
 # Branch: feature/add_new_method_for_containers
 #: tsr/services/sketch/sketch_service.py
-msgid "Task title can not be empty"
+msgid "Task title cannot be empty"
 msgstr "Task title is required"
 
 # Branch: feature/add_new_method_for_containers
@@ -427,7 +427,7 @@ msgstr "Incorrect slug specified: sketch not found"
 
 # Branch: feature/add_new_method_for_containers
 #: tsr/services/sketch/sketch_service.py
-msgid "You have local repo with remote, we can not work with this"
+msgid "You have local repo with remote, we cannot work with this"
 msgstr "Your local repository is linked to a remote: this configuration is not supported for the current operation"
 
 # Branch: feature/add_new_method_for_containers
@@ -442,12 +442,12 @@ msgstr "Your local repo has been modified and is not empty, please create an emp
 
 # Branch: feature/add_new_method_for_containers
 #: tsr/services/sketch/sketch_service.py
-msgid "We can not add remote, something wrong"
+msgid "We cannot add remote, something wrong"
 msgstr "Cannot add remote, something wrong"
 
 # Branch: feature/add_new_method_for_containers
 #: tsr/services/sketch/sketch_service.py
-msgid "You have local repo, we can not work with this"
+msgid "You have local repo, we cannot work with this"
 msgstr "Local repository in use: not supported for current operation"
 
 # Branch: feature/add_new_method_for_containers
@@ -517,12 +517,12 @@ msgstr "Path not found"
 
 # Branch: feature/add_new_method_for_containers
 #: tsr/services/filesystem_service.py
-msgid "We can not make dir"
+msgid "We cannot make dir"
 msgstr "Failed to create directory"
 
 # Branch: feature/add_new_method_for_containers
 #: tsr/services/filesystem_service.py
-msgid "We can not make file"
+msgid "We cannot make file"
 msgstr "Failed to create file"
 
 # Branch: feature/add_new_method_for_containers
@@ -692,12 +692,12 @@ msgstr "Cannot connect to rented or self-hosted instance"
 
 # Branch: feature/add_new_method_for_containers
 #: tsr/services/container/container_service.py
-msgid "Container name not present, can not connect to container"
+msgid "Container name not present, cannot connect to container"
 msgstr "Cannot connect to container: please specify container slug"
 
 # Branch: feature/add_new_method_for_containers
 #: tsr/services/container/container_service.py
-msgid "We can not get shell on container (bash, shell), please use standard shell"
+msgid "We cannot get shell on container (bash, shell), please use standard shell"
 msgstr "Unable to access the requested shell (bash, shell) in the container: please use the default shell available in the container"
 
 # Branch: feature/add_new_method_for_containers
@@ -722,7 +722,7 @@ msgstr "Specify username to connect to server instance"
 
 # Branch: feature/add_new_method_for_containers
 #: tsr/services/container/container_service.py
-msgid "Container is running, can not start working server"
+msgid "Container is running, cannot start working server"
 msgstr "Container is running: cannot start running container"
 
 # Branch: feature/add_new_method_for_containers
@@ -797,7 +797,7 @@ msgstr "Server instance slug not found"
 
 # Branch: feature/add_new_method_for_containers
 #: tsr/services/sketch/sketch_service.py
-msgid "Slug can not be empty"
+msgid "Slug cannot be empty"
 msgstr "Specify slug"
 
 # Branch: main
@@ -928,17 +928,17 @@ msgstr ""
 
 # Branch: main
 #: tsr/services/container/container_service.py
-msgid "Error, can not find mapping folders"
+msgid "Error, cannot find mapping folders"
 msgstr ""
 
 # Branch: main
 #: tsr/services/container/container_service.py
-msgid "Error, can not find mapping for /public folder"
+msgid "Error, cannot find mapping for /public folder"
 msgstr ""
 
 # Branch: main
 #: tsr/services/remote_server_service.py
-msgid "Can not find mapping folders"
+msgid "cannot find mapping folders"
 msgstr ""
 
 # Branch: main

thestage/inference_model/business/inference_model_service.py

@@ -0,0 +1,281 @@
+import time
+from datetime import datetime
+from typing import Optional, List
+
+import boto3
+import typer
+
+from thestage.config.business.config_provider import ConfigProvider
+from thestage.helpers.error_handler import error_handler
+from thestage.i18n.translation import __
+from thestage.inference_model.business.mapper.inference_model_mapper import InferenceModelMapper
+from thestage.inference_model.communication.inference_model_api_client import InferenceModelApiClient
+from thestage.inference_model.dto.deploy_inference_model_to_instance_response import \
+    DeployInferenceModelToInstanceResponse
+from thestage.inference_model.dto.deploy_inference_model_to_sagemaker_response import \
+    DeployInferenceModelToSagemakerResponse
+from thestage.inference_model.dto.enum.inference_model_status import InferenceModelStatus
+from thestage.inference_model.dto.inference_model import InferenceModel
+from thestage.inference_model.dto.inference_model_entity import InferenceModelEntity
+from thestage.project.business.project_service import ProjectService
+from thestage.project.dto.project_config import ProjectConfig
+from thestage.services.abstract_service import AbstractService
+from thestage.services.clients.thestage_api.dtos.paginated_entity_list import PaginatedEntityList
+
+
+class InferenceModelService(AbstractService):
+    def __init__(
+            self,
+            inference_model_api_client: InferenceModelApiClient,
+            config_provider: ConfigProvider,
+            project_service: ProjectService,
+    ):
+        self.__inference_model_api_client = inference_model_api_client
+        self.__config_provider = config_provider
+        self.__project_service = project_service
+
+
+    @error_handler()
+    def get_project_inference_simulator_model_list(
+            self,
+            project_public_id: Optional[str],
+            project_slug: Optional[str],
+            statuses: List[str],
+            row: int = 5,
+            page: int = 1,
+    ) -> PaginatedEntityList[InferenceModel]:
+        data: Optional[
+            PaginatedEntityList[InferenceModel]] = self.__inference_model_api_client.get_inference_simulator_model_list_for_project(
+            statuses=statuses,
+            project_public_id=project_public_id,
+            project_slug=project_slug,
+            page=page,
+            limit=row,
+        )
+
+        return data
+
+    @error_handler()
+    def project_deploy_inference_simulator_model_to_instance(
+            self,
+            model_public_id: Optional[str] = None,
+            model_slug: Optional[str] = None,
+            rented_instance_public_id: Optional[str] = None,
+            rented_instance_slug: Optional[str] = None,
+            self_hosted_instance_public_id: Optional[str] = None,
+            self_hosted_instance_slug: Optional[str] = None,
+    ) -> str:
+        config = self.__config_provider.get_config()
+        project_config: ProjectConfig = self.__project_service.get_fixed_project_config()
+        if not project_config:
+            typer.echo(
+                __("No project found at the path: %path%. Please initialize or clone a project first. Or provide path to project using --working-directory option.",
+                   {"path": config.runtime.working_directory}))
+            raise typer.Exit(1)
+
+        instance_args_count = sum(v is not None for v in
+                                  [rented_instance_public_id, rented_instance_slug, self_hosted_instance_public_id,
+                                   self_hosted_instance_slug])
+        if instance_args_count != 1:
+            typer.echo("Please provide a single instance (rented or self-hosted) identifier - name or ID.")
+            raise typer.Exit(1)
+
+        model_args_count = sum(v is not None for v in [model_public_id, model_slug])
+        if model_args_count != 1:
+            typer.echo("Please provide a single model identifier - name or ID.")
+            raise typer.Exit(1)
+
+        typer.echo(f"Creating inference simulator")
+        deploy_model_to_instance_response: DeployInferenceModelToInstanceResponse = self.__inference_model_api_client.deploy_inference_model_to_instance(
+            model_public_id=model_public_id,
+            model_slug=model_slug,
+            rented_instance_public_id=rented_instance_public_id,
+            rented_instance_slug=rented_instance_slug,
+            self_hosted_instance_public_id=self_hosted_instance_public_id,
+            self_hosted_instance_slug=self_hosted_instance_slug,
+        )
+        if deploy_model_to_instance_response:
+            if deploy_model_to_instance_response.message:
+                typer.echo(deploy_model_to_instance_response.message)
+            if deploy_model_to_instance_response.is_success:
+                typer.echo("Inference simulator has been scheduled to run successfully.")
+            else:
+                typer.echo(__(
+                    'Failed to start inference simulator: %server_massage%',
+                    {'server_massage': deploy_model_to_instance_response.message or ""}
+                ))
+                raise typer.Exit(1)
+        else:
+            typer.echo(__("Failed to start inference simulator"))
+            raise typer.Exit(1)
+
+        return deploy_model_to_instance_response.inferenceSimulatorPublicId
+
+
+    @error_handler()
+    def project_deploy_inference_simulator_model_to_sagemaker(
+            self,
+            model_public_id: Optional[str] = None,
+            model_slug: Optional[str] = None,
+            arn: Optional[str] = None,
+            instance_type: Optional[str] = None,
+            initial_variant_weight: Optional[float] = 1.0,
+            initial_instance_count: Optional[int] = None,
+    ) -> None:
+        config = self.__config_provider.get_config()
+        project_config: ProjectConfig = self.__project_service.get_fixed_project_config()
+        if not project_config:
+            typer.echo(
+                __("No project found at the path: %path%. Please initialize or clone a project first. Or provide path to project using --working-directory option.",
+                   {"path": config.runtime.working_directory}))
+            raise typer.Exit(1)
+
+        if not instance_type:
+            typer.echo(__("Error: Instance type is required."))
+            raise typer.Exit(1)
+
+        if not initial_instance_count:
+            typer.echo(__("Error: Initial instance count is required."))
+            raise typer.Exit(1)
+
+        if not arn:
+            typer.echo(__("Error: ARN is required."))
+            raise typer.Exit(1)
+
+        project_config: ProjectConfig = self.__config_provider.read_project_config()
+        if not project_config:
+            typer.echo(__("No project found at the path: %path%. Please initialize or clone a project first.",
+                          {"path": config.runtime.working_directory}))
+            raise typer.Exit(1)
+
+        deploy_model_to_sagemaker_response: DeployInferenceModelToSagemakerResponse = self.__inference_model_api_client.deploy_inference_model_to_sagemaker(
+            model_public_id=model_public_id,
+            model_slug=model_slug,
+            arn=arn,
+        )
+
+        if not deploy_model_to_sagemaker_response.is_success:
+            typer.echo(__(
+                'Model deployment preparation failed: %server_massage%',
+                {'server_massage': deploy_model_to_sagemaker_response.message or ""}
+            ))
+            raise typer.Exit(1)
+
+        model_id = deploy_model_to_sagemaker_response.modelId
+        image_uri = deploy_model_to_sagemaker_response.ecrImageUrl
+        model_uri = deploy_model_to_sagemaker_response.s3ArtifactsUrl
+        region = "us-east-1"
+        sm_client = boto3.client('sagemaker', region_name=region)
+
+        try:
+            container = {
+                "Image": image_uri,
+                "ModelDataUrl": model_uri,
+                "Environment": {
+                    "SAGEMAKER_TRITON_DEFAULT_MODEL_NAME": model_id,
+                    "THESTAGE_API_URL": config.main.thestage_api_url,
+                    "THESTAGE_AUTH_TOKEN": config.main.thestage_auth_token
+                },
+            }
+
+            sm_model_name = f"{model_slug}-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
+            create_model_response = sm_client.create_model(
+                ModelName=sm_model_name,
+                ExecutionRoleArn=arn,
+                PrimaryContainer=container,
+            )
+            typer.echo(f"Model created successfully. Model ARN: {create_model_response['ModelArn']}")
+
+            endpoint_config_name = f"{model_slug}-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
+            create_endpoint_config_response = sm_client.create_endpoint_config(
+                EndpointConfigName=endpoint_config_name,
+                ProductionVariants=[
+                    {
+                        "InstanceType": instance_type,
+                        "InitialVariantWeight": initial_variant_weight,
+                        "InitialInstanceCount": initial_instance_count,
+                        "ModelName": sm_model_name,
+                        "VariantName": "AllTraffic",
+                    }
+                ],
+            )
+            typer.echo(
+                f"Endpoint configuration created successfully. Endpoint Config ARN: {create_endpoint_config_response['EndpointConfigArn']}")
+
+            endpoint_name = f"{model_slug}-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
+            create_endpoint_response = sm_client.create_endpoint(
+                EndpointName=endpoint_name,
+                EndpointConfigName=endpoint_config_name,
+            )
+            typer.echo(f"Endpoint created successfully. Endpoint ARN: {create_endpoint_response['EndpointArn']}")
+
+            typer.echo("Waiting for the endpoint to become active...")
+            while True:
+                resp = sm_client.describe_endpoint(EndpointName=endpoint_name)
+                status = resp["EndpointStatus"]
+                typer.echo(f"Status: {status}")
+                if status == "InService":
+                    break
+                elif status == "Failed":
+                    typer.echo(f"Endpoint creation failed. Reason: {resp.get('FailureReason', 'Unknown')}")
+                    raise typer.Exit(1)
+                time.sleep(60)
+
+            typer.echo(f"Endpoint is ready. ARN: {resp['EndpointArn']} Status: {status}")
+
+        except Exception as e:
+            typer.echo(__("Failed to deploy the inference simulator model to SageMaker: %error%", {"error": str(e)}))
+            raise typer.Exit(1)
+
+
+    @error_handler()
+    def print_inference_simulator_model_list(self, project_public_id, project_slug, statuses, row, page):
+        if not project_public_id and not project_slug:
+            project_config: ProjectConfig = self.__config_provider.read_project_config()
+            if not project_config:
+                typer.echo(__("Provide the project unique ID or run this command from within an initialized project directory"))
+                raise typer.Exit(1)
+            project_public_id = project_config.public_id
+
+        inference_simulator_model_status_map = self.__inference_model_api_client.get_inference_simulator_model_business_status_map()
+
+        if not statuses:
+            statuses = ({key: inference_simulator_model_status_map[key] for key in [
+                InferenceModelStatus.SCHEDULED,
+                InferenceModelStatus.PROCESSING,
+                InferenceModelStatus.PUSH_SUCCEED,
+            ]}).values()
+
+        if "all" in statuses:
+            statuses = inference_simulator_model_status_map.values()
+
+        for input_status_item in statuses:
+            if input_status_item not in inference_simulator_model_status_map.values():
+                typer.echo(__("'%invalid_status%' is not one of %valid_statuses%", {
+                    'invalid_status': input_status_item,
+                    'valid_statuses': str(list(inference_simulator_model_status_map.values()))
+                }))
+                raise typer.Exit(1)
+
+        typer.echo(__(
+            "Listing inference simulator models with the following statuses: %statuses%, to view all inference simulator models, use --status all",
+            placeholders={
+                'statuses': ', '.join([status_item for status_item in statuses])
+            }))
+
+        backend_statuses: List[str] = [key for key, value in inference_simulator_model_status_map.items() if value in statuses]
+
+        self.print(
+            func_get_data=self.get_project_inference_simulator_model_list,
+            func_special_params={
+                'project_public_id': project_public_id,
+                'project_slug': project_slug,
+                'statuses': backend_statuses,
+            },
+            mapper=InferenceModelMapper(),
+            headers=list(map(lambda x: x.alias, InferenceModelEntity.model_fields.values())),
+            row=row,
+            page=page,
+            max_col_width=[100, 100, 100, 100, 25],
+            show_index="never",
+        )

thestage/{services/project/mapper/project_inference_simulator_model_mapper.py → inference_model/business/mapper/inference_model_mapper.py}

@@ -1,16 +1,16 @@
 from typing import Optional
 
-from thestage.entities.project_inference_simulator_model import ProjectInferenceSimulatorModelEntity
+from thestage.inference_model.dto.inference_model_entity import InferenceModelEntity
 from thestage.services.abstract_mapper import AbstractMapper
-from thestage.services.project.dto.inference_simulator_model_dto import InferenceSimulatorModelDto
+from thestage.inference_model.dto.inference_model import InferenceModel
 
 
-class ProjectInferenceSimulatorModelMapper(AbstractMapper):
-    def build_entity(self, item: InferenceSimulatorModelDto) -> Optional[ProjectInferenceSimulatorModelEntity]:
+class InferenceModelMapper(AbstractMapper):
+    def build_entity(self, item: InferenceModel) -> Optional[InferenceModelEntity]:
         if not item:
             return None
 
-        return ProjectInferenceSimulatorModelEntity(
+        return InferenceModelEntity(
             public_id=item.public_id,
             slug=item.slug,
             status=item.status or '',

thestage/inference_model/communication/inference_model_api_client.py

@@ -0,0 +1,139 @@
+from typing import Optional, List, Dict
+
+from thestage.config.business.config_provider import ConfigProvider
+from thestage.global_dto.enums.order_direction_type import OrderDirectionType
+from thestage.helpers.error_handler import error_handler
+from thestage.services.clients.thestage_api.core.api_client_core import TheStageApiClientCore
+from thestage.services.clients.thestage_api.dtos.entity_filter_request import EntityFilterRequest
+from thestage.services.clients.thestage_api.dtos.paginated_entity_list import PaginatedEntityList
+
+from thestage.inference_model.dto.inference_model import InferenceModel
+from thestage.inference_model.dto.inference_simulator_model_list_for_project_request import InferenceSimulatorModelListForProjectRequest
+from thestage.inference_model.dto.inference_simulator_model_list_for_project_response import InferenceSimulatorModelListForProjectResponse
+from thestage.inference_model.dto.push_inference_simulator_model_request import PushInferenceSimulatorModelRequest
+from thestage.inference_model.dto.push_inference_simulator_model_response import PushInferenceSimulatorModelResponse
+from thestage.inference_model.dto.inference_simulator_model_response import InferenceSimulatorModelStatusMapperResponse
+from thestage.inference_model.dto.deploy_inference_model_to_instance_request import DeployInferenceModelToInstanceRequest
+from thestage.inference_model.dto.deploy_inference_model_to_instance_response import DeployInferenceModelToInstanceResponse
+from thestage.inference_model.dto.deploy_inference_model_to_sagemaker_request import DeployInferenceModelToSagemakerRequest
+from thestage.inference_model.dto.deploy_inference_model_to_sagemaker_response import DeployInferenceModelToSagemakerResponse
+
+
+class InferenceModelApiClient(TheStageApiClientCore):
+    def __init__(self, config_provider: ConfigProvider):
+        super().__init__(url=config_provider.get_config().main.thestage_api_url)
+        self.__config_provider = config_provider
+
+    def get_inference_simulator_model_list_for_project(
+            self,
+            project_public_id: Optional[str],
+            project_slug: Optional[str],
+            statuses: Optional[List[str]] = None,
+            page: int = 1,
+            limit: int = 10,
+    ) -> Optional[PaginatedEntityList[InferenceModel]]:
+        request = InferenceSimulatorModelListForProjectRequest(
+            projectPublicId=project_public_id,
+            projectSlug=project_slug,
+            statuses=statuses,
+            entityFilterRequest=EntityFilterRequest(
+                orderByField="createdAt",
+                orderByDirection=OrderDirectionType.DESC,
+                page=page,
+                limit=limit,
+            ),
+        )
+
+        response = self._request(
+            method='POST',
+            url='/user-api/v2/inference-simulator-model/list',
+            data=request.model_dump(),
+            token=self.__config_provider.get_config().main.thestage_auth_token,
+        )
+        result = InferenceSimulatorModelListForProjectResponse.model_validate(response) if response else None
+        return result.inferenceSimulatorModels if result and result.is_success else None
+
+
+    def push_project_inference_simulator_model(
+            self,
+            public_id: Optional[str],
+            slug: Optional[str],
+    ) -> Optional[PushInferenceSimulatorModelResponse]:
+        request = PushInferenceSimulatorModelRequest(
+            inferenceSimulatorPublicId=public_id,
+            inferenceSimulatorSlug=slug,
+        )
+
+        response = self._request(
+            method='POST',
+            url='/user-api/v2/inference-simulator/push-model',
+            data=request.model_dump(),
+            token=self.__config_provider.get_config().main.thestage_auth_token,
+        )
+
+        return PushInferenceSimulatorModelResponse.model_validate(response) if response else None
+
+
+    def get_inference_simulator_model_business_status_map(self) -> Optional[Dict[str, str]]:
+        response = self._request(
+            method='POST',
+            url='/user-api/v1/inference-simulator-model/status-localized-mapping',
+            data=None,
+            token=self.__config_provider.get_config().main.thestage_auth_token,
+        )
+
+        data = InferenceSimulatorModelStatusMapperResponse.model_validate(response) if response else None
+
+        return data.inference_simulator_model_status_map if data else None
+
+
+    @error_handler()
+    def deploy_inference_model_to_instance(
+            self,
+            model_public_id: str,
+            model_slug: str,
+            new_inference_simulator_slug: str,
+            rented_instance_public_id: Optional[str] = None,
+            rented_instance_slug: Optional[str] = None,
+            self_hosted_instance_public_id: Optional[str] = None,
+            self_hosted_instance_slug: Optional[str] = None,
+
+    ) -> Optional[DeployInferenceModelToInstanceResponse]:
+        request = DeployInferenceModelToInstanceRequest(
+            modelPublicId=model_public_id,
+            modelSlug=model_slug,
+            instanceRentedPublicId=rented_instance_public_id,
+            instanceRentedSlug=rented_instance_slug,
+            selfhostedInstancePublicId=self_hosted_instance_public_id,
+            selfhostedInstanceSlug=self_hosted_instance_slug
+        )
+
+        response = self._request(
+            method='POST',
+            url='/user-api/v2/inference-simulator-model/deploy/instance',
+            data=request.model_dump(),
+            token=self.__config_provider.get_config().main.thestage_auth_token,
+        )
+        return DeployInferenceModelToInstanceResponse.model_validate(response) if response else None
+
+
+    @error_handler()
+    def deploy_inference_model_to_sagemaker(
+            self,
+            model_public_id: Optional[str],
+            model_slug: Optional[str],
+            arn: Optional[str] = None,
+    ) -> Optional[DeployInferenceModelToSagemakerResponse]:
+        request = DeployInferenceModelToSagemakerRequest(
+            modelPublicId=model_public_id,
+            modelSlug=model_slug,
+            arn=arn,
+        )
+
+        response = self._request(
+            method='POST',
+            url='/user-api/v1/inference-simulator-model/grant-user-arn-access',
+            data=request.model_dump(),
+            token=self.__config_provider.get_config().main.thestage_auth_token,
+        )
+        return DeployInferenceModelToSagemakerResponse.model_validate(response) if response else None