thestage 0.5.37__py3-none-any.whl → 0.5.39__py3-none-any.whl

thestage/services/logging/logging_service.py

@@ -8,8 +8,9 @@ import aioconsole
 import typer
 from httpx import ReadTimeout, ConnectError, ConnectTimeout
 from requests.exceptions import ChunkedEncodingError
-from thestage_core.entities.config_entity import ConfigEntity
 
+from thestage.services.clients.thestage_api.dtos.enums.container_status import DockerContainerStatus
+from thestage.services.core_files.config_entity import ConfigEntity
 from thestage.services.clients.thestage_api.dtos.enums.inference_simulator_status import InferenceSimulatorStatus
 from thestage.services.clients.thestage_api.dtos.enums.task_status import TaskStatus
 from thestage.services.clients.thestage_api.dtos.inference_controller.get_inference_simulator_response import \
@@ -69,25 +70,23 @@ class LoggingService(AbstractService):
 
 
     @error_handler()
-    def stream_container_logs(self, config: ConfigEntity, container: DockerContainerDto):
-        typer.echo(__(
-            f"Log stream for docker container '%container_slug%' started",
-            {
-                'container_slug': container.slug,
-            }
-        ))
-        typer.echo(__("Press CTRL+C to stop"))
-        try:
-            for log_json in self.__thestage_api_client.get_container_log_stream(
-                    token=config.main.thestage_auth_token,
-                    container_id=container.id
-            ):
-                self.__print_log_line(log_json)
-        except ChunkedEncodingError as e1:  # handling server timeout
-            typer.echo(__('Log stream disconnected (1)'))
+    def print_last_container_logs(self, config: ConfigEntity, container_uid: str, logs_number: Optional[int]):
+        container: Optional[DockerContainerDto] = self.__thestage_api_client.get_container(
+            token=config.main.thestage_auth_token,
+            container_slug=container_uid,
+        )
+
+        if not container:
+            typer.echo("Container was not found")
             raise typer.Exit(1)
 
-        typer.echo(__('Log stream disconnected'))
+        logs = self.__thestage_api_client.query_user_logs(
+            token=config.main.thestage_auth_token,
+            container_id=container.id,
+            limit=logs_number
+        )
+        for log_message in reversed(logs.queryResult):
+            self.__print_log_line_object(log_message)
 
 
     @error_handler()
@@ -134,7 +133,7 @@ class LoggingService(AbstractService):
 
         typer.echo(__("CTRL+C to cancel the task. CTRL+D to disconnect from log stream."))
 
-        print_logs_task = asyncio.create_task(self.print_task_or_inference_simulator_logs(config.main.thestage_auth_token, task.id))
+        print_logs_task = asyncio.create_task(self.print_realtime_logs(token=config.main.thestage_auth_token, task_id=task.id))
         input_task = asyncio.create_task(self.read_log_stream_input())
 
         def sigint_handler():
@@ -200,7 +199,7 @@ class LoggingService(AbstractService):
         typer.echo(__("CTRL+D to disconnect from log stream."))
 
         print_task_or_inference_simulator_logs = asyncio.create_task(
-            self.print_task_or_inference_simulator_logs(config.main.thestage_auth_token, inference_simulator_id=inference_simulator.id)
+            self.print_realtime_logs(token=config.main.thestage_auth_token, inference_simulator_id=inference_simulator.id)
         )
         input_task = asyncio.create_task(self.read_log_stream_input())
 
@@ -212,6 +211,49 @@ class LoggingService(AbstractService):
             typer.echo(__(f"Disconnected from log stream. You can try to reconnect with 'thestage project inference-simulator logs {slug}'."))
 
 
+    @error_handler()
+    def stream_container_logs_with_controls(self, config: ConfigEntity, container_uid: str):
+        asyncio.run(
+            self.__stream_container_logs_with_controls_async(
+                config=config,
+                container_uid=container_uid
+            )
+        )
+
+
+    @error_handler()
+    async def __stream_container_logs_with_controls_async(self, config: ConfigEntity, container_uid: str):
+        container: Optional[DockerContainerDto] = self.__thestage_api_client.get_container(
+            token=config.main.thestage_auth_token,
+            container_slug=container_uid,
+        )
+
+        if container:
+            if container.frontend_status.status_key not in [DockerContainerStatus.RUNNING]:
+                typer.echo(f"Container status: '{container.frontend_status.status_translation}'")
+        else:
+            typer.echo("Container was not found")
+            raise typer.Exit(1)
+
+        typer.echo(f"Log stream for Docker container started")
+        typer.echo("CTRL+D to disconnect from log stream.")
+
+        print_logs_task = asyncio.create_task(self.print_realtime_logs(token=config.main.thestage_auth_token, docker_container_id=container.id))
+        input_task = asyncio.create_task(self.read_log_stream_input())
+
+        def sigint_handler():
+            input_task.cancel()
+
+        loop = asyncio.get_event_loop()
+        for signal_item in [SIGINT]:  # SIGINT == CTRL+C
+            loop.add_signal_handler(signal_item, sigint_handler)
+
+        done, pending = await asyncio.wait([print_logs_task, input_task], return_when=asyncio.FIRST_COMPLETED)
+
+        if input_task in done:
+            print_logs_task.cancel()
+
+
     async def read_log_stream_input(self):
         try:
             while True:
@@ -223,7 +265,13 @@ class LoggingService(AbstractService):
             pass
 
 
-    async def print_task_or_inference_simulator_logs(self, token: str, task_id: Optional[int] = None, inference_simulator_id: Optional[int] = None):
+    async def print_realtime_logs(
+            self,
+            token: str,
+            task_id: Optional[int] = None,
+            inference_simulator_id: Optional[int] = None,
+            docker_container_id: Optional[int] = None,
+    ):
         polling_interval_seconds: float = 4  # also adjust polling api method timeout if changed
         between_logs_sleeping_coef: float = 1  # we emulate delay between logs, but if for any reason code runs for too long - delays will be controlled with this coef
         last_iteration_log_timestamp: Optional[str] = None  # pointer to next iteration polling start (obtained from each response)
@@ -249,7 +297,7 @@ class LoggingService(AbstractService):
                     token=token,
                     task_id=task_id,
                     inference_simulator_id=inference_simulator_id,
-                    docker_container_id=None,
+                    docker_container_id=docker_container_id,
                     last_log_timestamp=last_iteration_log_timestamp,
                     last_log_id=last_log_id
                 )
@@ -283,82 +331,15 @@ class LoggingService(AbstractService):
                     errors_started_at = datetime.utcnow()
 
             if consecutive_error_count > 7:
+                seconds_with_error = (datetime.utcnow() - errors_started_at).total_seconds()
                 if inference_simulator_id:
-                    seconds_with_error = (datetime.utcnow() - errors_started_at).total_seconds()
                     print_nonblocking(f"Log stream: disconnected from server (connectivity issues for {seconds_with_error} seconds). Try 'thestage inference-simulator logs <inference-simulator-UID>' to reconnect.", writer)
-                    break
+                elif task_id:
+                    print_nonblocking(f"Log stream: disconnected from server (connectivity issues for {seconds_with_error} seconds). Try 'thestage project task logs {task_id}' to reconnect.", writer)
+                elif docker_container_id:
+                    print_nonblocking(f"Log stream: disconnected from server (connectivity issues for {seconds_with_error} seconds). Try 'thestage container logs <docker-container-UID>' to reconnect.", writer)
                 else:
-                    seconds_with_error = (datetime.utcnow() - errors_started_at).total_seconds()
-                    print_nonblocking(f"Log stream: disconnected from server (connectivity issues for {seconds_with_error} seconds). Try 'thestage project inference-simulator logs {task_id}' to reconnect.", writer)
-                    break
-
-            # depending on iteration duration - sleep for the remaining time and adjust log sleep coefficient if needed
-            iteration_duration = (datetime.utcnow() - iteration_started_at).total_seconds()
-            if iteration_duration > polling_interval_seconds:
-                between_logs_sleeping_coef *= 0.85
-            else:
-                await asyncio.sleep(polling_interval_seconds - iteration_duration)
-                if between_logs_sleeping_coef < 1:
-                    between_logs_sleeping_coef = min(1.0, between_logs_sleeping_coef * 1.15)
-
-
-    async def print_inference_simulator_logs(self, token: str, inference_simulator_id: int):
-        polling_interval_seconds: float = 4  # also adjust polling api method timeout if changed
-        between_logs_sleeping_coef: float = 1  # we emulate delay between logs, but if for any reason code runs for too long - delays will be controlled with this coef
-        last_iteration_log_timestamp: Optional[str] = None  # pointer to next iteration polling start (obtained from each response)
-        last_log_id: Optional[str] = None  # pointer to next iteration polling start - to exclude the log id from result (obtained from each response)
-        consecutive_error_count: int = 0  # connectivity errors count - stream will disconnect if too many errors in a row
-        iteration_started_at: datetime  # used to control iteration duration - polling should be done at around exact rate
-        errors_started_at: Optional[datetime] = None  # time since errors started to stream disconnect
-
-        is_no_more_logs = False
-        while not is_no_more_logs:
-            log_wait_remaining_limit: float = polling_interval_seconds  # hard limit just in case
-            iteration_started_at = datetime.utcnow()
-            last_printed_log_timestamp: Optional[datetime] = None
-            reader, writer = await aioconsole.get_standard_streams()
-
-            # this shows (somewhat accurate) time difference between logs here and in real time. should not grow.
-            # if last_iteration_log_timestamp:
-            #     last_log_timestamp_parsed = datetime.strptime(last_iteration_log_timestamp, '%Y-%m-%dT%H:%M:%S.%f')
-            #     stream_to_logs_diff = datetime.utcnow() - last_log_timestamp_parsed
-            #     print_nonblocking(f'TDIFF {stream_to_logs_diff.total_seconds()}', writer)
-            try:
-                logs_response = await self.__thestage_api_client.poll_logs_httpx(
-                    token=token,
-                    inference_simulator_id=inference_simulator_id,
-                    docker_container_id=None,
-                    last_log_timestamp=last_iteration_log_timestamp,
-                    last_log_id=last_log_id
-                )
-
-                if consecutive_error_count > 0:
-                    consecutive_error_count = 0
-                    errors_started_at = None
-                    log_wait_remaining_limit = 0   # no log delays after reconnect
-
-                last_iteration_log_timestamp = logs_response.lastLogTimestamp
-                last_log_id = logs_response.lastLogId
-
-                for log_item in logs_response.logs:
-                    current_log_timestamp = datetime.strptime(log_item.timestamp[:26], '%Y-%m-%dT%H:%M:%S.%f')  # python does not like nanoseconds
-                    if last_printed_log_timestamp is not None and log_wait_remaining_limit > 0:
-                        logs_sleeptime = (current_log_timestamp - last_printed_log_timestamp).total_seconds() * between_logs_sleeping_coef
-                        await asyncio.sleep(logs_sleeptime)
-                        log_wait_remaining_limit -= logs_sleeptime
-                    self.__print_log_line_object_nonblocking(log_item, writer)
-                    last_printed_log_timestamp = current_log_timestamp
-
-            except (ReadTimeout, ConnectError, ConnectTimeout) as e:
-                consecutive_error_count += 1
-                if consecutive_error_count == 1:
-                    print_nonblocking("Network issues, attempting to re-establish connection...", writer, BytePrintStyle.ORANGE)
-                if not errors_started_at:
-                    errors_started_at = datetime.utcnow()
-
-            if consecutive_error_count > 7:
-                seconds_with_error = (datetime.utcnow() - errors_started_at).total_seconds()
-                print_nonblocking(f"Log stream: disconnected from server (connectivity issues for {seconds_with_error} seconds).", writer)
+                    print_nonblocking(f"Log stream: disconnected from server (connectivity issues for {seconds_with_error} seconds)", writer)
                 break
 
             # depending on iteration duration - sleep for the remaining time and adjust log sleep coefficient if needed

thestage/services/project/dto/inference_simulator_model_dto.py

@@ -5,6 +5,7 @@ class InferenceSimulatorModelDto(BaseModel):
     model_config = ConfigDict(use_enum_values=True)
 
     id: Optional[int] = Field(None, alias='id')
+    slug: Optional[str] = Field(None, alias='slug')
     client_id: Optional[int] = Field(None, alias='clientId')
     instance_rented_id: Optional[int] = Field(None, alias='instanceRentedId')
     selfhosted_instance_id: Optional[int] = Field(None, alias='selfhostedInstanceId')

thestage/services/project/mapper/project_inference_simulator_model_mapper.py

@@ -12,6 +12,7 @@ class ProjectInferenceSimulatorModelMapper(AbstractMapper):
 
         return ProjectInferenceSimulatorModelEntity(
             id=item.id,
+            slug=item.slug,
             status=item.status or '',
             commit_hash=item.commit_hash or '',
             environment_metadata=item.environment_metadata or '',

thestage/services/project/project_service.py

@@ -1,16 +1,19 @@
 import os
+import time
+from datetime import datetime
 from pathlib import Path
 from typing import Optional, List
 
 import json
+
+import boto3
 import click
 import typer
 from git import Commit
 from tabulate import tabulate
-from thestage_core.entities.config_entity import ConfigEntity
-from thestage_core.exceptions.http_error_exception import HttpClientException
-from thestage_core.services.filesystem_service import FileSystemServiceCore
 
+from thestage.services.clients.thestage_api.core.http_client_exception import HttpClientException
+from thestage.services.core_files.config_entity import ConfigEntity
 from thestage.color_scheme.color_scheme import ColorScheme
 from thestage.entities.enums.yes_no_response import YesOrNoResponse
 from thestage.exceptions.git_access_exception import GitAccessException
@@ -18,6 +21,10 @@ from thestage.i18n.translation import __
 from thestage.services.clients.git.git_client import GitLocalClient
 from thestage.services.clients.thestage_api.dtos.container_response import DockerContainerDto
 from thestage.services.clients.thestage_api.dtos.enums.container_status import DockerContainerStatus
+from thestage.services.clients.thestage_api.dtos.inference_controller.deploy_inference_model_to_instance_response import \
+    DeployInferenceModelToInstanceResponse
+from thestage.services.clients.thestage_api.dtos.inference_controller.deploy_inference_model_to_sagemaker_response import \
+    DeployInferenceModelToSagemakerResponse
 from thestage.services.clients.thestage_api.dtos.inference_controller.get_inference_simulator_response import \
     GetInferenceSimulatorResponse
 from thestage.services.clients.thestage_api.dtos.paginated_entity_list import PaginatedEntityList
@@ -29,6 +36,7 @@ from thestage.services.clients.thestage_api.dtos.project_controller.project_star
     ProjectStartInferenceSimulatorResponse
 from thestage.services.clients.thestage_api.dtos.project_response import ProjectDto
 from thestage.services.clients.thestage_api.dtos.task_controller.task_view_response import TaskViewResponse
+from thestage.services.filesystem_service import FileSystemServiceCore
 from thestage.services.project.dto.inference_simulator_dto import InferenceSimulatorDto
 from thestage.services.project.dto.inference_simulator_model_dto import InferenceSimulatorModelDto
 from thestage.services.task.dto.task_dto import TaskDto
@@ -359,11 +367,13 @@ class ProjectService(AbstractService):
             commit = self.__git_local_client.get_current_commit(path=config.runtime.working_directory)
             if commit and isinstance(commit, Commit):
                 commit_hash = commit.hexsha
-                task_title = commit.message.strip()
+                if not task_title:
+                    task_title = commit.message.strip()
         else:  # if commit_hash is defined
-            commit = self.__git_local_client.get_commit_by_hash(path=config.runtime.working_directory, commit_hash=commit_hash)
-            if commit and isinstance(commit, Commit):
-                task_title = commit.message.strip()
+            if not task_title:
+                commit = self.__git_local_client.get_commit_by_hash(path=config.runtime.working_directory, commit_hash=commit_hash)
+                if commit and isinstance(commit, Commit):
+                    task_title = commit.message.strip()
 
         if not task_title:  # should not happen but maybe git allows some kind of empty messages
             task_title = f'Task_{commit_hash}'
@@ -902,3 +912,170 @@ class ProjectService(AbstractService):
 
         return project_config
 
+    @error_handler()
+    def project_deploy_inference_simulator_model_to_instance(
+            self,
+            config: ConfigEntity,
+            unique_id: Optional[str] = None,
+            unique_id_with_timestamp: Optional[str] = None,
+            rented_instance_unique_id: Optional[str] = None,
+            self_hosted_instance_unique_id: Optional[str] = None,
+    ) -> None:
+        project_config: ProjectConfig = self.__get_fixed_project_config(config=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 rented_instance_unique_id and self_hosted_instance_unique_id:
+            typer.echo(__("Error: Cannot provide both rented and self-hosted instance unique IDs."))
+            raise typer.Exit(1)
+
+        if not rented_instance_unique_id and not self_hosted_instance_unique_id:
+            typer.echo(__("Error: Either a rented instance ID or a self-hosted instance unique ID must be provided."))
+            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)
+
+        typer.echo(__("Creating inference simulator with unique ID: %unique_id_with_timestamp%", {"unique_id_with_timestamp": unique_id_with_timestamp}))
+        deploy_model_to_instance_response: DeployInferenceModelToInstanceResponse = self.__thestage_api_client.deploy_inference_model_to_instance(
+            token=config.main.thestage_auth_token,
+            unique_id=unique_id,
+            unique_id_with_timestamp=unique_id_with_timestamp,
+            rented_instance_unique_id=rented_instance_unique_id,
+            self_hosted_instance_unique_id=self_hosted_instance_unique_id
+        )
+        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(__(
+                    'Inference simulator failed to run with an error: %server_massage%',
+                    {'server_massage': deploy_model_to_instance_response.message or ""}
+                ))
+                raise typer.Exit(1)
+        else:
+            typer.echo(__("Inference simulator failed to run with an error"))
+            raise typer.Exit(1)
+
+
+    @error_handler()
+    def project_deploy_inference_simulator_model_to_sagemaker(
+            self,
+            config: ConfigEntity,
+            unique_id: 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:
+        project_config: ProjectConfig = self.__get_fixed_project_config(config=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.__thestage_api_client.deploy_inference_model_to_sagemaker(
+            token=config.main.thestage_auth_token,
+            unique_id=unique_id,
+            arn=arn,
+        )
+
+        if not deploy_model_to_sagemaker_response.is_success:
+            typer.echo(__(
+                'Failed to prepare model for deployment with an error: %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"{unique_id}-{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"{unique_id}-{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"{unique_id}-{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)

thestage/services/remote_server_service.py

@@ -11,10 +11,9 @@ from click import Abort
 from paramiko.client import SSHClient
 from paramiko.pkey import PKey
 from paramiko.sftp_client import SFTPClient
-from thestage_core.entities.config_entity import ConfigEntity
-from thestage_core.entities.file_item import FileItemEntity
-from thestage_core.services.filesystem_service import FileSystemServiceCore
 
+from thestage.entities.file_item import FileItemEntity
+from thestage.services.core_files.config_entity import ConfigEntity
 from thestage.exceptions.remote_server_exception import RemoteServerException
 from thestage.helpers.logger.app_logger import app_logger
 from thestage.entities.enums.shell_type import ShellType
@@ -22,6 +21,7 @@ from thestage.helpers.ssh_util import parse_private_key
 from thestage.i18n.translation import __
 from thestage.services.clients.thestage_api.dtos.sftp_path_helper import SftpFileItemEntity
 from thestage.services.config_provider.config_provider import ConfigProvider
+from thestage.services.filesystem_service import FileSystemServiceCore
 
 old_value: int = 0
 

thestage/services/service_factory.py

@@ -1,8 +1,7 @@
 from typing import Optional
 
-from thestage_core.services.filesystem_service import FileSystemServiceCore
-
 from thestage.services.connect.connect_service import ConnectService
+from thestage.services.filesystem_service import FileSystemServiceCore
 from thestage.services.logging.logging_service import LoggingService
 from thestage.services.project.project_service import ProjectService
 from thestage.services.remote_server_service import RemoteServerService

thestage/services/validation_service.py

@@ -1,15 +1,12 @@
-from typing import Dict, Optional
-
 import typer
-from thestage_core.entities.config_entity import ConfigEntity, MainConfigEntity
-from thestage_core.services.validation_service import ValidationServiceCore
 
 from thestage.i18n.translation import __
 from thestage.services.config_provider.config_provider import ConfigProvider
 from thestage.services.clients.thestage_api.api_client import TheStageApiClient
+from thestage.services.core_files.config_entity import ConfigEntity
 
 
-class ValidationService(ValidationServiceCore):
+class ValidationService:
     _thestage_api_client: TheStageApiClient = None
 
     def __init__(
@@ -17,10 +14,9 @@ class ValidationService(ValidationServiceCore):
             thestage_api_client: TheStageApiClient,
             config_provider: ConfigProvider,
     ):
-        super(ValidationService, self).__init__(
-            thestage_api_client=thestage_api_client,
-            config_provider=config_provider,
-        )
+        self._thestage_api_client = thestage_api_client
+        self._config_provider = config_provider
+
 
     def check_token(
             self,
@@ -36,7 +32,9 @@ class ValidationService(ValidationServiceCore):
             )
 
 # TODO this fails with 503 error - AttributeError("'bytes' object has no attribute 'text'") from _parse_api_response method in core
-        is_valid = self.validate_token(token,)
+        is_valid: bool = False
+        if token:
+            is_valid = self._thestage_api_client.validate_token(token=token)
         if not is_valid:
             typer.echo(__(
                 'API token is invalid: generate API token using TheStage AI WebApp'
@@ -44,3 +42,21 @@ class ValidationService(ValidationServiceCore):
             raise typer.Exit(1)
 
         config.main.thestage_auth_token = token
+
+
+    @staticmethod
+    def is_present_token(config: ConfigEntity) -> bool:
+        present_token = True
+        if not config:
+            present_token = False
+        else:
+            if not config.main.thestage_auth_token:
+                present_token = False
+
+            if config.start_on_daemon:
+                if config.daemon and config.daemon.daemon_token:
+                    present_token = True
+                else:
+                    present_token = False
+
+        return present_token

{thestage-0.5.37.dist-info → thestage-0.5.39.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: thestage
-Version: 0.5.37
+Version: 0.5.39
 Summary: 
 Author: TheStage AI team
 Author-email: hello@thestage.ai
@@ -11,6 +11,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: aioconsole (>=0.8.0,<0.9.0)
+Requires-Dist: boto3 (>=1.35.80,<2.0.0)
 Requires-Dist: gitpython (>=3.1.40,<4.0.0)
 Requires-Dist: httpx (>=0.27.2,<0.28.0)
 Requires-Dist: paramiko (>=3.4.0,<4.0.0)
@@ -19,7 +20,6 @@ Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
 Requires-Dist: python-gettext-translations (>=1.1.0,<2.0.0)
 Requires-Dist: requests (>=2.31.0,<3.0.0)
 Requires-Dist: tabulate (>=0.9.0,<0.10.0)
-Requires-Dist: thestage-core (==0.0.16)
 Requires-Dist: typer[all] (>=0.9.0,<0.10.0)
 Description-Content-Type: text/markdown