thestage 0.5.46__py3-none-any.whl → 0.5.471__py3-none-any.whl

thestage/services/instance/instance_service.py

@@ -5,7 +5,6 @@ import typer
 
 from thestage.entities.rented_instance import RentedInstanceEntity
 from thestage.entities.self_hosted_instance import SelfHostedInstanceEntity
-from thestage.services.core_files.config_entity import ConfigEntity
 from thestage.i18n.translation import __
 from thestage.services.clients.thestage_api.dtos.enums.selfhosted_status import SelfhostedBusinessStatus
 from thestage.services.clients.thestage_api.dtos.enums.instance_rented_status import InstanceRentedBusinessStatus
@@ -24,6 +23,7 @@ from thestage.services.remote_server_service import RemoteServerService
 class InstanceService(AbstractService):
 
     __thestage_api_client: TheStageApiClient = None
+    __config_provider: ConfigProvider = None
 
     def __init__(
             self,
@@ -31,29 +31,23 @@ class InstanceService(AbstractService):
             config_provider: ConfigProvider,
             remote_server_service: RemoteServerService,
     ):
-        super(InstanceService, self).__init__(
-            config_provider=config_provider
-        )
         self.__thestage_api_client = thestage_api_client
         self.__remote_server_service = remote_server_service
+        self.__config_provider = config_provider
 
     def get_rented_instance(
             self,
-            config: ConfigEntity,
             instance_slug: str,
     ) -> Optional[InstanceRentedDto]:
         return self.__thestage_api_client.get_rented_instance(
-            token=config.main.thestage_auth_token,
             instance_slug=instance_slug,
         )
 
     def get_self_hosted_instance(
             self,
-            config: ConfigEntity,
             instance_slug: str,
     ) -> Optional[SelfHostedInstanceDto]:
         return self.__thestage_api_client.get_selfhosted_instance(
-            token=config.main.thestage_auth_token,
             instance_slug=instance_slug,
         )
 
@@ -123,10 +117,9 @@ class InstanceService(AbstractService):
     def connect_to_rented_instance(
             self,
             instance_rented_slug: str,
-            config: ConfigEntity,
             input_ssh_key_path: Optional[str]
     ):
-        instance = self.get_rented_instance(config=config, instance_slug=instance_rented_slug)
+        instance = self.get_rented_instance(instance_slug=instance_rented_slug)
 
         if instance:
             self.check_instance_status_to_connect(
@@ -135,7 +128,7 @@ class InstanceService(AbstractService):
 
             ssh_path_from_config: Optional[str] = None
             if not input_ssh_key_path:
-                ssh_path_from_config = self._config_provider.get_valid_private_key_path_by_ip_address(instance.ip_address)
+                ssh_path_from_config = self.__config_provider.get_valid_private_key_path_by_ip_address(instance.ip_address)
                 if ssh_path_from_config:
                     typer.echo(f"Using configured ssh key for this instance: {ssh_path_from_config}")
 
@@ -150,7 +143,7 @@ class InstanceService(AbstractService):
 
             # cannot really detect how ssh connection was ended. capturing stderr using subprocess feels bad/unreliable.
             if input_ssh_key_path:
-                self._config_provider.update_remote_server_config_entry(ip_address=instance.ip_address, ssh_key_path=Path(input_ssh_key_path))
+                self.__config_provider.update_remote_server_config_entry(ip_address=instance.ip_address, ssh_key_path=Path(input_ssh_key_path))
         else:
             typer.echo(__("Server instance not found: %instance_item%", {'instance_item': instance_rented_slug}))
 
@@ -160,14 +153,13 @@ class InstanceService(AbstractService):
             self,
             selfhosted_instance_slug: str,
             username: str,
-            config: ConfigEntity,
             input_ssh_key_path: Optional[str],
     ):
         if not username:
             username = 'root'
             typer.echo(__("No remote server username provided, using 'root' as username"))
 
-        instance = self.get_self_hosted_instance(config=config, instance_slug=selfhosted_instance_slug)
+        instance = self.get_self_hosted_instance(instance_slug=selfhosted_instance_slug)
 
         if instance:
             self.check_selfhosted_status_to_connect(
@@ -176,7 +168,7 @@ class InstanceService(AbstractService):
 
             ssh_path_from_config: Optional[str] = None
             if not input_ssh_key_path:
-                ssh_path_from_config = self._config_provider.get_valid_private_key_path_by_ip_address(instance.ip_address)
+                ssh_path_from_config = self.__config_provider.get_valid_private_key_path_by_ip_address(instance.ip_address)
                 if ssh_path_from_config:
                     typer.echo(f"Using configured ssh key for this instance: {ssh_path_from_config}")
 
@@ -190,7 +182,7 @@ class InstanceService(AbstractService):
             )
 
             if input_ssh_key_path:
-                self._config_provider.update_remote_server_config_entry(ip_address=instance.ip_address, ssh_key_path=Path(input_ssh_key_path))
+                self.__config_provider.update_remote_server_config_entry(ip_address=instance.ip_address, ssh_key_path=Path(input_ssh_key_path))
         else:
             typer.echo(__("Server instance not found: %instance_item%", {'instance_item': selfhosted_instance_slug}))
 
@@ -198,13 +190,11 @@ class InstanceService(AbstractService):
     @error_handler()
     def get_rented_list(
             self,
-            config: ConfigEntity,
             statuses: List[str],
             row: int = 5,
             page: int = 1,
     ) -> PaginatedEntityList[InstanceRentedDto]:
         data = self.__thestage_api_client.get_rented_instance_list(
-            token=config.main.thestage_auth_token,
             statuses=statuses,
             page=page,
             limit=row,
@@ -215,13 +205,11 @@ class InstanceService(AbstractService):
     @error_handler()
     def get_self_hosted_list(
             self,
-            config: ConfigEntity,
             statuses: List[str],
             row: int = 5,
             page: int = 1,
     ) -> PaginatedEntityList[SelfHostedInstanceDto]:
         data = self.__thestage_api_client.get_selfhosted_instance_list(
-            token=config.main.thestage_auth_token,
             statuses=statuses,
             page=page,
             limit=row,
@@ -230,8 +218,8 @@ class InstanceService(AbstractService):
 
 
     @error_handler()
-    def print_self_hosted_instance_list(self, config: ConfigEntity, statuses, row, page):
-        selfhosted_instance_status_map = self.__thestage_api_client.get_selfhosted_business_status_map(config.main.thestage_auth_token)
+    def print_self_hosted_instance_list(self, statuses, row, page):
+        selfhosted_instance_status_map = self.__thestage_api_client.get_selfhosted_business_status_map()
 
         if not statuses:
             statuses = ({key: selfhosted_instance_status_map[key] for key in [
@@ -265,7 +253,6 @@ class InstanceService(AbstractService):
                 'statuses': backend_statuses,
             },
             mapper=SelfHostedMapper(),
-            config=config,
             headers=list(map(lambda x: x.alias, SelfHostedInstanceEntity.model_fields.values())),
             row=row,
             page=page,
@@ -274,8 +261,8 @@ class InstanceService(AbstractService):
 
 
     @error_handler()
-    def print_rented_instance_list(self, config: ConfigEntity, statuses, row, page):
-        instance_rented_status_map = self.__thestage_api_client.get_rented_business_status_map(config.main.thestage_auth_token)
+    def print_rented_instance_list(self, statuses, row, page):
+        instance_rented_status_map = self.__thestage_api_client.get_rented_business_status_map()
 
         if not statuses:
             statuses = ({key: instance_rented_status_map[key] for key in [
@@ -310,7 +297,6 @@ class InstanceService(AbstractService):
                 'statuses': backend_statuses,
             },
             mapper=InstanceMapper(),
-            config=config,
             headers=list(map(lambda x: x.alias, RentedInstanceEntity.model_fields.values())),
             row=row,
             page=page,

thestage/services/logging/logging_service.py

@@ -7,11 +7,9 @@ from typing import Optional, Dict
 import aioconsole
 import typer
 from httpx import ReadTimeout, ConnectError, ConnectTimeout
-from requests.exceptions import ChunkedEncodingError
 
 from thestage.helpers.logger.app_logger import app_logger
 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 \
@@ -25,7 +23,6 @@ from thestage.services.abstract_service import AbstractService
 from thestage.services.clients.thestage_api.dtos.container_response import DockerContainerDto
 from thestage.helpers.error_handler import error_handler
 from thestage.services.clients.thestage_api.api_client import TheStageApiClient
-from thestage.services.config_provider.config_provider import ConfigProvider
 from rich import print
 
 from thestage.services.logging.exception.log_polling_exception import LogPollingException
@@ -35,24 +32,19 @@ from thestage.services.logging.logging_constants import LOG_MESSAGE_CODE_TASK_FI
 is_logs_streaming = False
 
 
-class LoggingService(AbstractService):
+class LoggingService:
     __thestage_api_client: TheStageApiClient = None
 
     def __init__(
             self,
             thestage_api_client: TheStageApiClient,
-            config_provider: ConfigProvider,
     ):
-        super(LoggingService, self).__init__(
-            config_provider=config_provider
-        )
         self.__thestage_api_client = thestage_api_client
 
 
     @error_handler()
-    def print_last_task_logs(self, config: ConfigEntity, task_id: int, logs_number: Optional[int]):
+    def print_last_task_logs(self, task_id: int, logs_number: Optional[int]):
         logs = self.__thestage_api_client.query_user_logs(
-            token=config.main.thestage_auth_token,
             task_id=task_id,
             limit=logs_number
         )
@@ -61,9 +53,8 @@ class LoggingService(AbstractService):
 
 
     @error_handler()
-    def print_last_inference_simulator_logs(self, config: ConfigEntity, inference_simulator_id: int, logs_number: Optional[int]):
+    def print_last_inference_simulator_logs(self, inference_simulator_id: int, logs_number: Optional[int]):
         logs = self.__thestage_api_client.query_user_logs(
-            token=config.main.thestage_auth_token,
             inference_simulator_id=inference_simulator_id,
             limit=logs_number
         )
@@ -72,9 +63,8 @@ class LoggingService(AbstractService):
 
 
     @error_handler()
-    def print_last_container_logs(self, config: ConfigEntity, container_uid: str, logs_number: Optional[int]):
+    def print_last_container_logs(self, 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,
         )
 
@@ -83,7 +73,6 @@ class LoggingService(AbstractService):
             raise typer.Exit(1)
 
         logs = self.__thestage_api_client.query_user_logs(
-            token=config.main.thestage_auth_token,
             container_id=container.id,
             limit=logs_number
         )
@@ -92,25 +81,17 @@ class LoggingService(AbstractService):
 
 
     @error_handler()
-    def stream_task_logs_with_controls(self, config: ConfigEntity, task_id: int):
+    def stream_task_logs_with_controls(self, task_id: int):
         asyncio.run(
-            self.__stream_task_logs_with_controls_async(
-                config=config,
-                task_id=task_id
-            )
+            self.__stream_task_logs_with_controls_async(task_id=task_id)
         )
 
 
     @error_handler()
-    async def __stream_task_logs_with_controls_async(self, config: ConfigEntity, task_id: int):
-        task_view_response: Optional[TaskViewResponse] = self.__thestage_api_client.get_task(
-            token=config.main.thestage_auth_token,
-            task_id=task_id,
-        )
+    async def __stream_task_logs_with_controls_async(self, task_id: int):
+        task_view_response: Optional[TaskViewResponse] = self.__thestage_api_client.get_task(task_id=task_id,)
 
-        task_status_map: Dict[str, str] = self.__thestage_api_client.get_task_localized_status_map(
-            token=config.main.thestage_auth_token,
-        )
+        task_status_map: Dict[str, str] = self.__thestage_api_client.get_task_localized_status_map()
 
         task = task_view_response.task
 
@@ -135,7 +116,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_realtime_logs(token=config.main.thestage_auth_token, task_id=task.id))
+        print_logs_task = asyncio.create_task(self.print_realtime_logs(task_id=task.id))
         input_task = asyncio.create_task(self.read_log_stream_input())
 
         def sigint_handler():
@@ -152,29 +133,24 @@ class LoggingService(AbstractService):
             if not input_task.result():  # result is only expected if ctrl+D triggered EOFError
                 typer.echo(f"\rTask {task_id} will be canceled")
                 self.__thestage_api_client.cancel_task(
-                    token=config.main.thestage_auth_token,
                     task_id=task.id,
                 )
 
     @error_handler()
-    def stream_inference_simulator_logs_with_controls(self, config: ConfigEntity, slug: str):
+    def stream_inference_simulator_logs_with_controls(self, slug: str):
         asyncio.run(
             self.__stream_inference_simulator_logs_with_controls_async(
-                config=config,
                 slug=slug
             )
         )
 
     @error_handler()
-    async def __stream_inference_simulator_logs_with_controls_async(self, config: ConfigEntity, slug: str):
+    async def __stream_inference_simulator_logs_with_controls_async(self, slug: str):
         get_inference_simulator_response: Optional[GetInferenceSimulatorResponse] = self.__thestage_api_client.get_inference_simulator(
-            token=config.main.thestage_auth_token,
             slug=slug,
         )
 
-        inference_simulator_status_map: Dict[str, str] = self.__thestage_api_client.get_inference_simulator_business_status_map(
-            token=config.main.thestage_auth_token,
-        )
+        inference_simulator_status_map: Dict[str, str] = self.__thestage_api_client.get_inference_simulator_business_status_map()
 
         inference_simulator = get_inference_simulator_response.inferenceSimulator
 
@@ -201,7 +177,7 @@ class LoggingService(AbstractService):
         typer.echo(__("CTRL+D to disconnect from log stream."))
 
         print_task_or_inference_simulator_logs = asyncio.create_task(
-            self.print_realtime_logs(token=config.main.thestage_auth_token, inference_simulator_id=inference_simulator.id)
+            self.print_realtime_logs(inference_simulator_id=inference_simulator.id)
         )
         input_task = asyncio.create_task(self.read_log_stream_input())
 
@@ -214,19 +190,17 @@ class LoggingService(AbstractService):
 
 
     @error_handler()
-    def stream_container_logs_with_controls(self, config: ConfigEntity, container_uid: str):
+    def stream_container_logs_with_controls(self, 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):
+    async def __stream_container_logs_with_controls_async(self, container_uid: str):
         container: Optional[DockerContainerDto] = self.__thestage_api_client.get_container(
-            token=config.main.thestage_auth_token,
             container_slug=container_uid,
         )
 
@@ -240,7 +214,7 @@ class LoggingService(AbstractService):
         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))
+        print_logs_task = asyncio.create_task(self.print_realtime_logs(docker_container_id=container.id))
         input_task = asyncio.create_task(self.read_log_stream_input())
 
         def sigint_handler():
@@ -269,7 +243,6 @@ class LoggingService(AbstractService):
 
     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,
@@ -296,7 +269,6 @@ class LoggingService(AbstractService):
             #     print_nonblocking(f'TDIFF {stream_to_logs_diff.total_seconds()}', writer)
             try:
                 logs_response = await self.__thestage_api_client.poll_logs_httpx(
-                    token=token,
                     task_id=task_id,
                     inference_simulator_id=inference_simulator_id,
                     docker_container_id=docker_container_id,